ec1f89217a
Full Mattermost server source with integrated Community Enterprise features. Includes vendor directory for offline/air-gapped builds. Structure: - enterprise-impl/: Enterprise feature implementations - enterprise-community/: Init files that register implementations - enterprise/: Bridge imports (community_imports.go) - vendor/: All dependencies for offline builds Build (online): go build ./cmd/mattermost Build (offline/air-gapped): go build -mod=vendor ./cmd/mattermost 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
1714 lines
39 KiB
Go
1714 lines
39 KiB
Go
// Code generated DO NOT EDIT
|
|
|
|
package cmds
|
|
|
|
import "strconv"
|
|
|
|
type AclCat Incomplete
|
|
|
|
func (b Builder) AclCat() (c AclCat) {
|
|
c = AclCat{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "CAT")
|
|
return c
|
|
}
|
|
|
|
func (c AclCat) Categoryname(categoryname string) AclCatCategoryname {
|
|
c.cs.s = append(c.cs.s, categoryname)
|
|
return (AclCatCategoryname)(c)
|
|
}
|
|
|
|
func (c AclCat) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclCatCategoryname Incomplete
|
|
|
|
func (c AclCatCategoryname) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclDeluser Incomplete
|
|
|
|
func (b Builder) AclDeluser() (c AclDeluser) {
|
|
c = AclDeluser{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "DELUSER")
|
|
return c
|
|
}
|
|
|
|
func (c AclDeluser) Username(username ...string) AclDeluserUsername {
|
|
c.cs.s = append(c.cs.s, username...)
|
|
return (AclDeluserUsername)(c)
|
|
}
|
|
|
|
type AclDeluserUsername Incomplete
|
|
|
|
func (c AclDeluserUsername) Username(username ...string) AclDeluserUsername {
|
|
c.cs.s = append(c.cs.s, username...)
|
|
return c
|
|
}
|
|
|
|
func (c AclDeluserUsername) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclDryrun Incomplete
|
|
|
|
func (b Builder) AclDryrun() (c AclDryrun) {
|
|
c = AclDryrun{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "DRYRUN")
|
|
return c
|
|
}
|
|
|
|
func (c AclDryrun) Username(username string) AclDryrunUsername {
|
|
c.cs.s = append(c.cs.s, username)
|
|
return (AclDryrunUsername)(c)
|
|
}
|
|
|
|
type AclDryrunArg Incomplete
|
|
|
|
func (c AclDryrunArg) Arg(arg ...string) AclDryrunArg {
|
|
c.cs.s = append(c.cs.s, arg...)
|
|
return c
|
|
}
|
|
|
|
func (c AclDryrunArg) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclDryrunCommand Incomplete
|
|
|
|
func (c AclDryrunCommand) Arg(arg ...string) AclDryrunArg {
|
|
c.cs.s = append(c.cs.s, arg...)
|
|
return (AclDryrunArg)(c)
|
|
}
|
|
|
|
func (c AclDryrunCommand) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclDryrunUsername Incomplete
|
|
|
|
func (c AclDryrunUsername) Command(command string) AclDryrunCommand {
|
|
c.cs.s = append(c.cs.s, command)
|
|
return (AclDryrunCommand)(c)
|
|
}
|
|
|
|
type AclGenpass Incomplete
|
|
|
|
func (b Builder) AclGenpass() (c AclGenpass) {
|
|
c = AclGenpass{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "GENPASS")
|
|
return c
|
|
}
|
|
|
|
func (c AclGenpass) Bits(bits int64) AclGenpassBits {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(bits, 10))
|
|
return (AclGenpassBits)(c)
|
|
}
|
|
|
|
func (c AclGenpass) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclGenpassBits Incomplete
|
|
|
|
func (c AclGenpassBits) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclGetuser Incomplete
|
|
|
|
func (b Builder) AclGetuser() (c AclGetuser) {
|
|
c = AclGetuser{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "GETUSER")
|
|
return c
|
|
}
|
|
|
|
func (c AclGetuser) Username(username string) AclGetuserUsername {
|
|
c.cs.s = append(c.cs.s, username)
|
|
return (AclGetuserUsername)(c)
|
|
}
|
|
|
|
type AclGetuserUsername Incomplete
|
|
|
|
func (c AclGetuserUsername) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclHelp Incomplete
|
|
|
|
func (b Builder) AclHelp() (c AclHelp) {
|
|
c = AclHelp{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "HELP")
|
|
return c
|
|
}
|
|
|
|
func (c AclHelp) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclList Incomplete
|
|
|
|
func (b Builder) AclList() (c AclList) {
|
|
c = AclList{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "LIST")
|
|
return c
|
|
}
|
|
|
|
func (c AclList) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclLoad Incomplete
|
|
|
|
func (b Builder) AclLoad() (c AclLoad) {
|
|
c = AclLoad{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "LOAD")
|
|
return c
|
|
}
|
|
|
|
func (c AclLoad) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclLog Incomplete
|
|
|
|
func (b Builder) AclLog() (c AclLog) {
|
|
c = AclLog{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "LOG")
|
|
return c
|
|
}
|
|
|
|
func (c AclLog) Count(count int64) AclLogCountCount {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
|
|
return (AclLogCountCount)(c)
|
|
}
|
|
|
|
func (c AclLog) Reset() AclLogCountReset {
|
|
c.cs.s = append(c.cs.s, "RESET")
|
|
return (AclLogCountReset)(c)
|
|
}
|
|
|
|
type AclLogCountCount Incomplete
|
|
|
|
func (c AclLogCountCount) Reset() AclLogCountReset {
|
|
c.cs.s = append(c.cs.s, "RESET")
|
|
return (AclLogCountReset)(c)
|
|
}
|
|
|
|
func (c AclLogCountCount) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclLogCountReset Incomplete
|
|
|
|
func (c AclLogCountReset) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclSave Incomplete
|
|
|
|
func (b Builder) AclSave() (c AclSave) {
|
|
c = AclSave{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "SAVE")
|
|
return c
|
|
}
|
|
|
|
func (c AclSave) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclSetuser Incomplete
|
|
|
|
func (b Builder) AclSetuser() (c AclSetuser) {
|
|
c = AclSetuser{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "SETUSER")
|
|
return c
|
|
}
|
|
|
|
func (c AclSetuser) Username(username string) AclSetuserUsername {
|
|
c.cs.s = append(c.cs.s, username)
|
|
return (AclSetuserUsername)(c)
|
|
}
|
|
|
|
type AclSetuserRule Incomplete
|
|
|
|
func (c AclSetuserRule) Rule(rule ...string) AclSetuserRule {
|
|
c.cs.s = append(c.cs.s, rule...)
|
|
return c
|
|
}
|
|
|
|
func (c AclSetuserRule) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclSetuserUsername Incomplete
|
|
|
|
func (c AclSetuserUsername) Rule(rule ...string) AclSetuserRule {
|
|
c.cs.s = append(c.cs.s, rule...)
|
|
return (AclSetuserRule)(c)
|
|
}
|
|
|
|
func (c AclSetuserUsername) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclUsers Incomplete
|
|
|
|
func (b Builder) AclUsers() (c AclUsers) {
|
|
c = AclUsers{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "USERS")
|
|
return c
|
|
}
|
|
|
|
func (c AclUsers) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type AclWhoami Incomplete
|
|
|
|
func (b Builder) AclWhoami() (c AclWhoami) {
|
|
c = AclWhoami{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ACL", "WHOAMI")
|
|
return c
|
|
}
|
|
|
|
func (c AclWhoami) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Bgrewriteaof Incomplete
|
|
|
|
func (b Builder) Bgrewriteaof() (c Bgrewriteaof) {
|
|
c = Bgrewriteaof{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "BGREWRITEAOF")
|
|
return c
|
|
}
|
|
|
|
func (c Bgrewriteaof) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Bgsave Incomplete
|
|
|
|
func (b Builder) Bgsave() (c Bgsave) {
|
|
c = Bgsave{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "BGSAVE")
|
|
return c
|
|
}
|
|
|
|
func (c Bgsave) Schedule() BgsaveSchedule {
|
|
c.cs.s = append(c.cs.s, "SCHEDULE")
|
|
return (BgsaveSchedule)(c)
|
|
}
|
|
|
|
func (c Bgsave) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BgsaveSchedule Incomplete
|
|
|
|
func (c BgsaveSchedule) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Command Incomplete
|
|
|
|
func (b Builder) Command() (c Command) {
|
|
c = Command{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "COMMAND")
|
|
return c
|
|
}
|
|
|
|
func (c Command) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandCount Incomplete
|
|
|
|
func (b Builder) CommandCount() (c CommandCount) {
|
|
c = CommandCount{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "COMMAND", "COUNT")
|
|
return c
|
|
}
|
|
|
|
func (c CommandCount) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandDocs Incomplete
|
|
|
|
func (b Builder) CommandDocs() (c CommandDocs) {
|
|
c = CommandDocs{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "COMMAND", "DOCS")
|
|
return c
|
|
}
|
|
|
|
func (c CommandDocs) CommandName(commandName ...string) CommandDocsCommandName {
|
|
c.cs.s = append(c.cs.s, commandName...)
|
|
return (CommandDocsCommandName)(c)
|
|
}
|
|
|
|
func (c CommandDocs) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandDocsCommandName Incomplete
|
|
|
|
func (c CommandDocsCommandName) CommandName(commandName ...string) CommandDocsCommandName {
|
|
c.cs.s = append(c.cs.s, commandName...)
|
|
return c
|
|
}
|
|
|
|
func (c CommandDocsCommandName) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandGetkeys Incomplete
|
|
|
|
func (b Builder) CommandGetkeys() (c CommandGetkeys) {
|
|
c = CommandGetkeys{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "COMMAND", "GETKEYS")
|
|
return c
|
|
}
|
|
|
|
func (c CommandGetkeys) Command(command string) CommandGetkeysCommand {
|
|
c.cs.s = append(c.cs.s, command)
|
|
return (CommandGetkeysCommand)(c)
|
|
}
|
|
|
|
type CommandGetkeysArg Incomplete
|
|
|
|
func (c CommandGetkeysArg) Arg(arg ...string) CommandGetkeysArg {
|
|
c.cs.s = append(c.cs.s, arg...)
|
|
return c
|
|
}
|
|
|
|
func (c CommandGetkeysArg) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandGetkeysCommand Incomplete
|
|
|
|
func (c CommandGetkeysCommand) Arg(arg ...string) CommandGetkeysArg {
|
|
c.cs.s = append(c.cs.s, arg...)
|
|
return (CommandGetkeysArg)(c)
|
|
}
|
|
|
|
func (c CommandGetkeysCommand) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandGetkeysandflags Incomplete
|
|
|
|
func (b Builder) CommandGetkeysandflags() (c CommandGetkeysandflags) {
|
|
c = CommandGetkeysandflags{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "COMMAND", "GETKEYSANDFLAGS")
|
|
return c
|
|
}
|
|
|
|
func (c CommandGetkeysandflags) Command(command string) CommandGetkeysandflagsCommand {
|
|
c.cs.s = append(c.cs.s, command)
|
|
return (CommandGetkeysandflagsCommand)(c)
|
|
}
|
|
|
|
type CommandGetkeysandflagsArg Incomplete
|
|
|
|
func (c CommandGetkeysandflagsArg) Arg(arg ...string) CommandGetkeysandflagsArg {
|
|
c.cs.s = append(c.cs.s, arg...)
|
|
return c
|
|
}
|
|
|
|
func (c CommandGetkeysandflagsArg) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandGetkeysandflagsCommand Incomplete
|
|
|
|
func (c CommandGetkeysandflagsCommand) Arg(arg ...string) CommandGetkeysandflagsArg {
|
|
c.cs.s = append(c.cs.s, arg...)
|
|
return (CommandGetkeysandflagsArg)(c)
|
|
}
|
|
|
|
func (c CommandGetkeysandflagsCommand) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandInfo Incomplete
|
|
|
|
func (b Builder) CommandInfo() (c CommandInfo) {
|
|
c = CommandInfo{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "COMMAND", "INFO")
|
|
return c
|
|
}
|
|
|
|
func (c CommandInfo) CommandName(commandName ...string) CommandInfoCommandName {
|
|
c.cs.s = append(c.cs.s, commandName...)
|
|
return (CommandInfoCommandName)(c)
|
|
}
|
|
|
|
func (c CommandInfo) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandInfoCommandName Incomplete
|
|
|
|
func (c CommandInfoCommandName) CommandName(commandName ...string) CommandInfoCommandName {
|
|
c.cs.s = append(c.cs.s, commandName...)
|
|
return c
|
|
}
|
|
|
|
func (c CommandInfoCommandName) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandList Incomplete
|
|
|
|
func (b Builder) CommandList() (c CommandList) {
|
|
c = CommandList{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "COMMAND", "LIST")
|
|
return c
|
|
}
|
|
|
|
func (c CommandList) FilterbyModuleName(name string) CommandListFilterbyModuleName {
|
|
c.cs.s = append(c.cs.s, "FILTERBY", "MODULE", name)
|
|
return (CommandListFilterbyModuleName)(c)
|
|
}
|
|
|
|
func (c CommandList) FilterbyAclcatCategory(category string) CommandListFilterbyAclcatCategory {
|
|
c.cs.s = append(c.cs.s, "FILTERBY", "ACLCAT", category)
|
|
return (CommandListFilterbyAclcatCategory)(c)
|
|
}
|
|
|
|
func (c CommandList) FilterbyPatternPattern(pattern string) CommandListFilterbyPatternPattern {
|
|
c.cs.s = append(c.cs.s, "FILTERBY", "PATTERN", pattern)
|
|
return (CommandListFilterbyPatternPattern)(c)
|
|
}
|
|
|
|
func (c CommandList) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandListFilterbyAclcatCategory Incomplete
|
|
|
|
func (c CommandListFilterbyAclcatCategory) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandListFilterbyModuleName Incomplete
|
|
|
|
func (c CommandListFilterbyModuleName) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CommandListFilterbyPatternPattern Incomplete
|
|
|
|
func (c CommandListFilterbyPatternPattern) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ConfigGet Incomplete
|
|
|
|
func (b Builder) ConfigGet() (c ConfigGet) {
|
|
c = ConfigGet{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CONFIG", "GET")
|
|
return c
|
|
}
|
|
|
|
func (c ConfigGet) Parameter(parameter ...string) ConfigGetParameter {
|
|
c.cs.s = append(c.cs.s, parameter...)
|
|
return (ConfigGetParameter)(c)
|
|
}
|
|
|
|
type ConfigGetParameter Incomplete
|
|
|
|
func (c ConfigGetParameter) Parameter(parameter ...string) ConfigGetParameter {
|
|
c.cs.s = append(c.cs.s, parameter...)
|
|
return c
|
|
}
|
|
|
|
func (c ConfigGetParameter) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ConfigResetstat Incomplete
|
|
|
|
func (b Builder) ConfigResetstat() (c ConfigResetstat) {
|
|
c = ConfigResetstat{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CONFIG", "RESETSTAT")
|
|
return c
|
|
}
|
|
|
|
func (c ConfigResetstat) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ConfigRewrite Incomplete
|
|
|
|
func (b Builder) ConfigRewrite() (c ConfigRewrite) {
|
|
c = ConfigRewrite{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CONFIG", "REWRITE")
|
|
return c
|
|
}
|
|
|
|
func (c ConfigRewrite) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ConfigSet Incomplete
|
|
|
|
func (b Builder) ConfigSet() (c ConfigSet) {
|
|
c = ConfigSet{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CONFIG", "SET")
|
|
return c
|
|
}
|
|
|
|
func (c ConfigSet) ParameterValue() ConfigSetParameterValue {
|
|
return (ConfigSetParameterValue)(c)
|
|
}
|
|
|
|
type ConfigSetParameterValue Incomplete
|
|
|
|
func (c ConfigSetParameterValue) ParameterValue(parameter string, value string) ConfigSetParameterValue {
|
|
c.cs.s = append(c.cs.s, parameter, value)
|
|
return c
|
|
}
|
|
|
|
func (c ConfigSetParameterValue) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Dbsize Incomplete
|
|
|
|
func (b Builder) Dbsize() (c Dbsize) {
|
|
c = Dbsize{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "DBSIZE")
|
|
return c
|
|
}
|
|
|
|
func (c Dbsize) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type DebugObject Incomplete
|
|
|
|
func (b Builder) DebugObject() (c DebugObject) {
|
|
c = DebugObject{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "DEBUG", "OBJECT")
|
|
return c
|
|
}
|
|
|
|
func (c DebugObject) Key(key string) DebugObjectKey {
|
|
if c.ks&NoSlot == NoSlot {
|
|
c.ks = NoSlot | slot(key)
|
|
} else {
|
|
c.ks = check(c.ks, slot(key))
|
|
}
|
|
c.cs.s = append(c.cs.s, key)
|
|
return (DebugObjectKey)(c)
|
|
}
|
|
|
|
type DebugObjectKey Incomplete
|
|
|
|
func (c DebugObjectKey) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type DebugSegfault Incomplete
|
|
|
|
func (b Builder) DebugSegfault() (c DebugSegfault) {
|
|
c = DebugSegfault{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "DEBUG", "SEGFAULT")
|
|
return c
|
|
}
|
|
|
|
func (c DebugSegfault) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Failover Incomplete
|
|
|
|
func (b Builder) Failover() (c Failover) {
|
|
c = Failover{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "FAILOVER")
|
|
return c
|
|
}
|
|
|
|
func (c Failover) To() FailoverTargetTo {
|
|
c.cs.s = append(c.cs.s, "TO")
|
|
return (FailoverTargetTo)(c)
|
|
}
|
|
|
|
func (c Failover) Abort() FailoverAbort {
|
|
c.cs.s = append(c.cs.s, "ABORT")
|
|
return (FailoverAbort)(c)
|
|
}
|
|
|
|
func (c Failover) Timeout(milliseconds int64) FailoverTimeout {
|
|
c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
|
|
return (FailoverTimeout)(c)
|
|
}
|
|
|
|
func (c Failover) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type FailoverAbort Incomplete
|
|
|
|
func (c FailoverAbort) Timeout(milliseconds int64) FailoverTimeout {
|
|
c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
|
|
return (FailoverTimeout)(c)
|
|
}
|
|
|
|
func (c FailoverAbort) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type FailoverTargetForce Incomplete
|
|
|
|
func (c FailoverTargetForce) Abort() FailoverAbort {
|
|
c.cs.s = append(c.cs.s, "ABORT")
|
|
return (FailoverAbort)(c)
|
|
}
|
|
|
|
func (c FailoverTargetForce) Timeout(milliseconds int64) FailoverTimeout {
|
|
c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
|
|
return (FailoverTimeout)(c)
|
|
}
|
|
|
|
func (c FailoverTargetForce) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type FailoverTargetHost Incomplete
|
|
|
|
func (c FailoverTargetHost) Port(port int64) FailoverTargetPort {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(port, 10))
|
|
return (FailoverTargetPort)(c)
|
|
}
|
|
|
|
type FailoverTargetPort Incomplete
|
|
|
|
func (c FailoverTargetPort) Force() FailoverTargetForce {
|
|
c.cs.s = append(c.cs.s, "FORCE")
|
|
return (FailoverTargetForce)(c)
|
|
}
|
|
|
|
func (c FailoverTargetPort) Abort() FailoverAbort {
|
|
c.cs.s = append(c.cs.s, "ABORT")
|
|
return (FailoverAbort)(c)
|
|
}
|
|
|
|
func (c FailoverTargetPort) Timeout(milliseconds int64) FailoverTimeout {
|
|
c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
|
|
return (FailoverTimeout)(c)
|
|
}
|
|
|
|
func (c FailoverTargetPort) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type FailoverTargetTo Incomplete
|
|
|
|
func (c FailoverTargetTo) Host(host string) FailoverTargetHost {
|
|
c.cs.s = append(c.cs.s, host)
|
|
return (FailoverTargetHost)(c)
|
|
}
|
|
|
|
type FailoverTimeout Incomplete
|
|
|
|
func (c FailoverTimeout) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Flushall Incomplete
|
|
|
|
func (b Builder) Flushall() (c Flushall) {
|
|
c = Flushall{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "FLUSHALL")
|
|
return c
|
|
}
|
|
|
|
func (c Flushall) Async() FlushallAsync {
|
|
c.cs.s = append(c.cs.s, "ASYNC")
|
|
return (FlushallAsync)(c)
|
|
}
|
|
|
|
func (c Flushall) Sync() FlushallAsyncSync {
|
|
c.cs.s = append(c.cs.s, "SYNC")
|
|
return (FlushallAsyncSync)(c)
|
|
}
|
|
|
|
func (c Flushall) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type FlushallAsync Incomplete
|
|
|
|
func (c FlushallAsync) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type FlushallAsyncSync Incomplete
|
|
|
|
func (c FlushallAsyncSync) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Flushdb Incomplete
|
|
|
|
func (b Builder) Flushdb() (c Flushdb) {
|
|
c = Flushdb{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "FLUSHDB")
|
|
return c
|
|
}
|
|
|
|
func (c Flushdb) Async() FlushdbAsync {
|
|
c.cs.s = append(c.cs.s, "ASYNC")
|
|
return (FlushdbAsync)(c)
|
|
}
|
|
|
|
func (c Flushdb) Sync() FlushdbAsyncSync {
|
|
c.cs.s = append(c.cs.s, "SYNC")
|
|
return (FlushdbAsyncSync)(c)
|
|
}
|
|
|
|
func (c Flushdb) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type FlushdbAsync Incomplete
|
|
|
|
func (c FlushdbAsync) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type FlushdbAsyncSync Incomplete
|
|
|
|
func (c FlushdbAsyncSync) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Info Incomplete
|
|
|
|
func (b Builder) Info() (c Info) {
|
|
c = Info{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "INFO")
|
|
return c
|
|
}
|
|
|
|
func (c Info) Section(section ...string) InfoSection {
|
|
c.cs.s = append(c.cs.s, section...)
|
|
return (InfoSection)(c)
|
|
}
|
|
|
|
func (c Info) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type InfoSection Incomplete
|
|
|
|
func (c InfoSection) Section(section ...string) InfoSection {
|
|
c.cs.s = append(c.cs.s, section...)
|
|
return c
|
|
}
|
|
|
|
func (c InfoSection) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Lastsave Incomplete
|
|
|
|
func (b Builder) Lastsave() (c Lastsave) {
|
|
c = Lastsave{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "LASTSAVE")
|
|
return c
|
|
}
|
|
|
|
func (c Lastsave) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type LatencyDoctor Incomplete
|
|
|
|
func (b Builder) LatencyDoctor() (c LatencyDoctor) {
|
|
c = LatencyDoctor{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "LATENCY", "DOCTOR")
|
|
return c
|
|
}
|
|
|
|
func (c LatencyDoctor) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type LatencyGraph Incomplete
|
|
|
|
func (b Builder) LatencyGraph() (c LatencyGraph) {
|
|
c = LatencyGraph{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "LATENCY", "GRAPH")
|
|
return c
|
|
}
|
|
|
|
func (c LatencyGraph) Event(event string) LatencyGraphEvent {
|
|
c.cs.s = append(c.cs.s, event)
|
|
return (LatencyGraphEvent)(c)
|
|
}
|
|
|
|
type LatencyGraphEvent Incomplete
|
|
|
|
func (c LatencyGraphEvent) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type LatencyHelp Incomplete
|
|
|
|
func (b Builder) LatencyHelp() (c LatencyHelp) {
|
|
c = LatencyHelp{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "LATENCY", "HELP")
|
|
return c
|
|
}
|
|
|
|
func (c LatencyHelp) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type LatencyHistogram Incomplete
|
|
|
|
func (b Builder) LatencyHistogram() (c LatencyHistogram) {
|
|
c = LatencyHistogram{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "LATENCY", "HISTOGRAM")
|
|
return c
|
|
}
|
|
|
|
func (c LatencyHistogram) Command(command ...string) LatencyHistogramCommand {
|
|
c.cs.s = append(c.cs.s, command...)
|
|
return (LatencyHistogramCommand)(c)
|
|
}
|
|
|
|
func (c LatencyHistogram) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type LatencyHistogramCommand Incomplete
|
|
|
|
func (c LatencyHistogramCommand) Command(command ...string) LatencyHistogramCommand {
|
|
c.cs.s = append(c.cs.s, command...)
|
|
return c
|
|
}
|
|
|
|
func (c LatencyHistogramCommand) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type LatencyHistory Incomplete
|
|
|
|
func (b Builder) LatencyHistory() (c LatencyHistory) {
|
|
c = LatencyHistory{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "LATENCY", "HISTORY")
|
|
return c
|
|
}
|
|
|
|
func (c LatencyHistory) Event(event string) LatencyHistoryEvent {
|
|
c.cs.s = append(c.cs.s, event)
|
|
return (LatencyHistoryEvent)(c)
|
|
}
|
|
|
|
type LatencyHistoryEvent Incomplete
|
|
|
|
func (c LatencyHistoryEvent) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type LatencyLatest Incomplete
|
|
|
|
func (b Builder) LatencyLatest() (c LatencyLatest) {
|
|
c = LatencyLatest{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "LATENCY", "LATEST")
|
|
return c
|
|
}
|
|
|
|
func (c LatencyLatest) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type LatencyReset Incomplete
|
|
|
|
func (b Builder) LatencyReset() (c LatencyReset) {
|
|
c = LatencyReset{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "LATENCY", "RESET")
|
|
return c
|
|
}
|
|
|
|
func (c LatencyReset) Event(event ...string) LatencyResetEvent {
|
|
c.cs.s = append(c.cs.s, event...)
|
|
return (LatencyResetEvent)(c)
|
|
}
|
|
|
|
func (c LatencyReset) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type LatencyResetEvent Incomplete
|
|
|
|
func (c LatencyResetEvent) Event(event ...string) LatencyResetEvent {
|
|
c.cs.s = append(c.cs.s, event...)
|
|
return c
|
|
}
|
|
|
|
func (c LatencyResetEvent) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Lolwut Incomplete
|
|
|
|
func (b Builder) Lolwut() (c Lolwut) {
|
|
c = Lolwut{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "LOLWUT")
|
|
return c
|
|
}
|
|
|
|
func (c Lolwut) Version(version int64) LolwutVersion {
|
|
c.cs.s = append(c.cs.s, "VERSION", strconv.FormatInt(version, 10))
|
|
return (LolwutVersion)(c)
|
|
}
|
|
|
|
func (c Lolwut) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type LolwutVersion Incomplete
|
|
|
|
func (c LolwutVersion) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type MemoryDoctor Incomplete
|
|
|
|
func (b Builder) MemoryDoctor() (c MemoryDoctor) {
|
|
c = MemoryDoctor{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "MEMORY", "DOCTOR")
|
|
return c
|
|
}
|
|
|
|
func (c MemoryDoctor) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type MemoryHelp Incomplete
|
|
|
|
func (b Builder) MemoryHelp() (c MemoryHelp) {
|
|
c = MemoryHelp{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "MEMORY", "HELP")
|
|
return c
|
|
}
|
|
|
|
func (c MemoryHelp) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type MemoryMallocStats Incomplete
|
|
|
|
func (b Builder) MemoryMallocStats() (c MemoryMallocStats) {
|
|
c = MemoryMallocStats{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "MEMORY", "MALLOC-STATS")
|
|
return c
|
|
}
|
|
|
|
func (c MemoryMallocStats) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type MemoryPurge Incomplete
|
|
|
|
func (b Builder) MemoryPurge() (c MemoryPurge) {
|
|
c = MemoryPurge{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "MEMORY", "PURGE")
|
|
return c
|
|
}
|
|
|
|
func (c MemoryPurge) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type MemoryStats Incomplete
|
|
|
|
func (b Builder) MemoryStats() (c MemoryStats) {
|
|
c = MemoryStats{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "MEMORY", "STATS")
|
|
return c
|
|
}
|
|
|
|
func (c MemoryStats) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type MemoryUsage Incomplete
|
|
|
|
func (b Builder) MemoryUsage() (c MemoryUsage) {
|
|
c = MemoryUsage{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "MEMORY", "USAGE")
|
|
return c
|
|
}
|
|
|
|
func (c MemoryUsage) Key(key string) MemoryUsageKey {
|
|
if c.ks&NoSlot == NoSlot {
|
|
c.ks = NoSlot | slot(key)
|
|
} else {
|
|
c.ks = check(c.ks, slot(key))
|
|
}
|
|
c.cs.s = append(c.cs.s, key)
|
|
return (MemoryUsageKey)(c)
|
|
}
|
|
|
|
type MemoryUsageKey Incomplete
|
|
|
|
func (c MemoryUsageKey) Samples(count int64) MemoryUsageSamples {
|
|
c.cs.s = append(c.cs.s, "SAMPLES", strconv.FormatInt(count, 10))
|
|
return (MemoryUsageSamples)(c)
|
|
}
|
|
|
|
func (c MemoryUsageKey) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type MemoryUsageSamples Incomplete
|
|
|
|
func (c MemoryUsageSamples) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ModuleList Incomplete
|
|
|
|
func (b Builder) ModuleList() (c ModuleList) {
|
|
c = ModuleList{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "MODULE", "LIST")
|
|
return c
|
|
}
|
|
|
|
func (c ModuleList) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ModuleLoad Incomplete
|
|
|
|
func (b Builder) ModuleLoad() (c ModuleLoad) {
|
|
c = ModuleLoad{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "MODULE", "LOAD")
|
|
return c
|
|
}
|
|
|
|
func (c ModuleLoad) Path(path string) ModuleLoadPath {
|
|
c.cs.s = append(c.cs.s, path)
|
|
return (ModuleLoadPath)(c)
|
|
}
|
|
|
|
type ModuleLoadArg Incomplete
|
|
|
|
func (c ModuleLoadArg) Arg(arg ...string) ModuleLoadArg {
|
|
c.cs.s = append(c.cs.s, arg...)
|
|
return c
|
|
}
|
|
|
|
func (c ModuleLoadArg) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ModuleLoadPath Incomplete
|
|
|
|
func (c ModuleLoadPath) Arg(arg ...string) ModuleLoadArg {
|
|
c.cs.s = append(c.cs.s, arg...)
|
|
return (ModuleLoadArg)(c)
|
|
}
|
|
|
|
func (c ModuleLoadPath) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ModuleLoadex Incomplete
|
|
|
|
func (b Builder) ModuleLoadex() (c ModuleLoadex) {
|
|
c = ModuleLoadex{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "MODULE", "LOADEX")
|
|
return c
|
|
}
|
|
|
|
func (c ModuleLoadex) Path(path string) ModuleLoadexPath {
|
|
c.cs.s = append(c.cs.s, path)
|
|
return (ModuleLoadexPath)(c)
|
|
}
|
|
|
|
type ModuleLoadexArgs Incomplete
|
|
|
|
func (c ModuleLoadexArgs) Args(args ...string) ModuleLoadexArgs {
|
|
c.cs.s = append(c.cs.s, "ARGS")
|
|
c.cs.s = append(c.cs.s, args...)
|
|
return c
|
|
}
|
|
|
|
func (c ModuleLoadexArgs) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ModuleLoadexConfig Incomplete
|
|
|
|
func (c ModuleLoadexConfig) Config(name string, value string) ModuleLoadexConfig {
|
|
c.cs.s = append(c.cs.s, "CONFIG", name, value)
|
|
return c
|
|
}
|
|
|
|
func (c ModuleLoadexConfig) Args(args ...string) ModuleLoadexArgs {
|
|
c.cs.s = append(c.cs.s, "ARGS")
|
|
c.cs.s = append(c.cs.s, args...)
|
|
return (ModuleLoadexArgs)(c)
|
|
}
|
|
|
|
func (c ModuleLoadexConfig) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ModuleLoadexPath Incomplete
|
|
|
|
func (c ModuleLoadexPath) Config() ModuleLoadexConfig {
|
|
return (ModuleLoadexConfig)(c)
|
|
}
|
|
|
|
func (c ModuleLoadexPath) Args(args ...string) ModuleLoadexArgs {
|
|
c.cs.s = append(c.cs.s, "ARGS")
|
|
c.cs.s = append(c.cs.s, args...)
|
|
return (ModuleLoadexArgs)(c)
|
|
}
|
|
|
|
func (c ModuleLoadexPath) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ModuleUnload Incomplete
|
|
|
|
func (b Builder) ModuleUnload() (c ModuleUnload) {
|
|
c = ModuleUnload{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "MODULE", "UNLOAD")
|
|
return c
|
|
}
|
|
|
|
func (c ModuleUnload) Name(name string) ModuleUnloadName {
|
|
c.cs.s = append(c.cs.s, name)
|
|
return (ModuleUnloadName)(c)
|
|
}
|
|
|
|
type ModuleUnloadName Incomplete
|
|
|
|
func (c ModuleUnloadName) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Monitor Incomplete
|
|
|
|
func (b Builder) Monitor() (c Monitor) {
|
|
c = Monitor{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "MONITOR")
|
|
return c
|
|
}
|
|
|
|
func (c Monitor) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Psync Incomplete
|
|
|
|
func (b Builder) Psync() (c Psync) {
|
|
c = Psync{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "PSYNC")
|
|
return c
|
|
}
|
|
|
|
func (c Psync) Replicationid(replicationid string) PsyncReplicationid {
|
|
c.cs.s = append(c.cs.s, replicationid)
|
|
return (PsyncReplicationid)(c)
|
|
}
|
|
|
|
type PsyncOffset Incomplete
|
|
|
|
func (c PsyncOffset) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type PsyncReplicationid Incomplete
|
|
|
|
func (c PsyncReplicationid) Offset(offset int64) PsyncOffset {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
|
|
return (PsyncOffset)(c)
|
|
}
|
|
|
|
type Replicaof Incomplete
|
|
|
|
func (b Builder) Replicaof() (c Replicaof) {
|
|
c = Replicaof{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "REPLICAOF")
|
|
return c
|
|
}
|
|
|
|
func (c Replicaof) Host(host string) ReplicaofArgsHostPortHost {
|
|
c.cs.s = append(c.cs.s, host)
|
|
return (ReplicaofArgsHostPortHost)(c)
|
|
}
|
|
|
|
func (c Replicaof) No() ReplicaofArgsNoOneNo {
|
|
c.cs.s = append(c.cs.s, "NO")
|
|
return (ReplicaofArgsNoOneNo)(c)
|
|
}
|
|
|
|
type ReplicaofArgsHostPortHost Incomplete
|
|
|
|
func (c ReplicaofArgsHostPortHost) Port(port int64) ReplicaofArgsHostPortPort {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(port, 10))
|
|
return (ReplicaofArgsHostPortPort)(c)
|
|
}
|
|
|
|
type ReplicaofArgsHostPortPort Incomplete
|
|
|
|
func (c ReplicaofArgsHostPortPort) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ReplicaofArgsNoOneNo Incomplete
|
|
|
|
func (c ReplicaofArgsNoOneNo) One() ReplicaofArgsNoOneOne {
|
|
c.cs.s = append(c.cs.s, "ONE")
|
|
return (ReplicaofArgsNoOneOne)(c)
|
|
}
|
|
|
|
type ReplicaofArgsNoOneOne Incomplete
|
|
|
|
func (c ReplicaofArgsNoOneOne) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Role Incomplete
|
|
|
|
func (b Builder) Role() (c Role) {
|
|
c = Role{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "ROLE")
|
|
return c
|
|
}
|
|
|
|
func (c Role) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Save Incomplete
|
|
|
|
func (b Builder) Save() (c Save) {
|
|
c = Save{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "SAVE")
|
|
return c
|
|
}
|
|
|
|
func (c Save) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Shutdown Incomplete
|
|
|
|
func (b Builder) Shutdown() (c Shutdown) {
|
|
c = Shutdown{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "SHUTDOWN")
|
|
return c
|
|
}
|
|
|
|
func (c Shutdown) Nosave() ShutdownSaveModeNosave {
|
|
c.cs.s = append(c.cs.s, "NOSAVE")
|
|
return (ShutdownSaveModeNosave)(c)
|
|
}
|
|
|
|
func (c Shutdown) Save() ShutdownSaveModeSave {
|
|
c.cs.s = append(c.cs.s, "SAVE")
|
|
return (ShutdownSaveModeSave)(c)
|
|
}
|
|
|
|
func (c Shutdown) Now() ShutdownNow {
|
|
c.cs.s = append(c.cs.s, "NOW")
|
|
return (ShutdownNow)(c)
|
|
}
|
|
|
|
func (c Shutdown) Force() ShutdownForce {
|
|
c.cs.s = append(c.cs.s, "FORCE")
|
|
return (ShutdownForce)(c)
|
|
}
|
|
|
|
func (c Shutdown) Safe() ShutdownSafe {
|
|
c.cs.s = append(c.cs.s, "SAFE")
|
|
return (ShutdownSafe)(c)
|
|
}
|
|
|
|
func (c Shutdown) Abort() ShutdownAbort {
|
|
c.cs.s = append(c.cs.s, "ABORT")
|
|
return (ShutdownAbort)(c)
|
|
}
|
|
|
|
func (c Shutdown) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ShutdownAbort Incomplete
|
|
|
|
func (c ShutdownAbort) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ShutdownForce Incomplete
|
|
|
|
func (c ShutdownForce) Safe() ShutdownSafe {
|
|
c.cs.s = append(c.cs.s, "SAFE")
|
|
return (ShutdownSafe)(c)
|
|
}
|
|
|
|
func (c ShutdownForce) Abort() ShutdownAbort {
|
|
c.cs.s = append(c.cs.s, "ABORT")
|
|
return (ShutdownAbort)(c)
|
|
}
|
|
|
|
func (c ShutdownForce) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ShutdownNow Incomplete
|
|
|
|
func (c ShutdownNow) Force() ShutdownForce {
|
|
c.cs.s = append(c.cs.s, "FORCE")
|
|
return (ShutdownForce)(c)
|
|
}
|
|
|
|
func (c ShutdownNow) Safe() ShutdownSafe {
|
|
c.cs.s = append(c.cs.s, "SAFE")
|
|
return (ShutdownSafe)(c)
|
|
}
|
|
|
|
func (c ShutdownNow) Abort() ShutdownAbort {
|
|
c.cs.s = append(c.cs.s, "ABORT")
|
|
return (ShutdownAbort)(c)
|
|
}
|
|
|
|
func (c ShutdownNow) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ShutdownSafe Incomplete
|
|
|
|
func (c ShutdownSafe) Abort() ShutdownAbort {
|
|
c.cs.s = append(c.cs.s, "ABORT")
|
|
return (ShutdownAbort)(c)
|
|
}
|
|
|
|
func (c ShutdownSafe) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ShutdownSaveModeNosave Incomplete
|
|
|
|
func (c ShutdownSaveModeNosave) Now() ShutdownNow {
|
|
c.cs.s = append(c.cs.s, "NOW")
|
|
return (ShutdownNow)(c)
|
|
}
|
|
|
|
func (c ShutdownSaveModeNosave) Force() ShutdownForce {
|
|
c.cs.s = append(c.cs.s, "FORCE")
|
|
return (ShutdownForce)(c)
|
|
}
|
|
|
|
func (c ShutdownSaveModeNosave) Safe() ShutdownSafe {
|
|
c.cs.s = append(c.cs.s, "SAFE")
|
|
return (ShutdownSafe)(c)
|
|
}
|
|
|
|
func (c ShutdownSaveModeNosave) Abort() ShutdownAbort {
|
|
c.cs.s = append(c.cs.s, "ABORT")
|
|
return (ShutdownAbort)(c)
|
|
}
|
|
|
|
func (c ShutdownSaveModeNosave) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type ShutdownSaveModeSave Incomplete
|
|
|
|
func (c ShutdownSaveModeSave) Now() ShutdownNow {
|
|
c.cs.s = append(c.cs.s, "NOW")
|
|
return (ShutdownNow)(c)
|
|
}
|
|
|
|
func (c ShutdownSaveModeSave) Force() ShutdownForce {
|
|
c.cs.s = append(c.cs.s, "FORCE")
|
|
return (ShutdownForce)(c)
|
|
}
|
|
|
|
func (c ShutdownSaveModeSave) Safe() ShutdownSafe {
|
|
c.cs.s = append(c.cs.s, "SAFE")
|
|
return (ShutdownSafe)(c)
|
|
}
|
|
|
|
func (c ShutdownSaveModeSave) Abort() ShutdownAbort {
|
|
c.cs.s = append(c.cs.s, "ABORT")
|
|
return (ShutdownAbort)(c)
|
|
}
|
|
|
|
func (c ShutdownSaveModeSave) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Slaveof Incomplete
|
|
|
|
func (b Builder) Slaveof() (c Slaveof) {
|
|
c = Slaveof{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "SLAVEOF")
|
|
return c
|
|
}
|
|
|
|
func (c Slaveof) Host(host string) SlaveofArgsHostPortHost {
|
|
c.cs.s = append(c.cs.s, host)
|
|
return (SlaveofArgsHostPortHost)(c)
|
|
}
|
|
|
|
func (c Slaveof) No() SlaveofArgsNoOneNo {
|
|
c.cs.s = append(c.cs.s, "NO")
|
|
return (SlaveofArgsNoOneNo)(c)
|
|
}
|
|
|
|
type SlaveofArgsHostPortHost Incomplete
|
|
|
|
func (c SlaveofArgsHostPortHost) Port(port int64) SlaveofArgsHostPortPort {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(port, 10))
|
|
return (SlaveofArgsHostPortPort)(c)
|
|
}
|
|
|
|
type SlaveofArgsHostPortPort Incomplete
|
|
|
|
func (c SlaveofArgsHostPortPort) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type SlaveofArgsNoOneNo Incomplete
|
|
|
|
func (c SlaveofArgsNoOneNo) One() SlaveofArgsNoOneOne {
|
|
c.cs.s = append(c.cs.s, "ONE")
|
|
return (SlaveofArgsNoOneOne)(c)
|
|
}
|
|
|
|
type SlaveofArgsNoOneOne Incomplete
|
|
|
|
func (c SlaveofArgsNoOneOne) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type SlowlogGet Incomplete
|
|
|
|
func (b Builder) SlowlogGet() (c SlowlogGet) {
|
|
c = SlowlogGet{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "SLOWLOG", "GET")
|
|
return c
|
|
}
|
|
|
|
func (c SlowlogGet) Count(count int64) SlowlogGetCount {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
|
|
return (SlowlogGetCount)(c)
|
|
}
|
|
|
|
func (c SlowlogGet) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type SlowlogGetCount Incomplete
|
|
|
|
func (c SlowlogGetCount) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type SlowlogHelp Incomplete
|
|
|
|
func (b Builder) SlowlogHelp() (c SlowlogHelp) {
|
|
c = SlowlogHelp{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "SLOWLOG", "HELP")
|
|
return c
|
|
}
|
|
|
|
func (c SlowlogHelp) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type SlowlogLen Incomplete
|
|
|
|
func (b Builder) SlowlogLen() (c SlowlogLen) {
|
|
c = SlowlogLen{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "SLOWLOG", "LEN")
|
|
return c
|
|
}
|
|
|
|
func (c SlowlogLen) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type SlowlogReset Incomplete
|
|
|
|
func (b Builder) SlowlogReset() (c SlowlogReset) {
|
|
c = SlowlogReset{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "SLOWLOG", "RESET")
|
|
return c
|
|
}
|
|
|
|
func (c SlowlogReset) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Swapdb Incomplete
|
|
|
|
func (b Builder) Swapdb() (c Swapdb) {
|
|
c = Swapdb{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "SWAPDB")
|
|
return c
|
|
}
|
|
|
|
func (c Swapdb) Index1(index1 int64) SwapdbIndex1 {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(index1, 10))
|
|
return (SwapdbIndex1)(c)
|
|
}
|
|
|
|
type SwapdbIndex1 Incomplete
|
|
|
|
func (c SwapdbIndex1) Index2(index2 int64) SwapdbIndex2 {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(index2, 10))
|
|
return (SwapdbIndex2)(c)
|
|
}
|
|
|
|
type SwapdbIndex2 Incomplete
|
|
|
|
func (c SwapdbIndex2) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Sync Incomplete
|
|
|
|
func (b Builder) Sync() (c Sync) {
|
|
c = Sync{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "SYNC")
|
|
return c
|
|
}
|
|
|
|
func (c Sync) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Time Incomplete
|
|
|
|
func (b Builder) Time() (c Time) {
|
|
c = Time{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "TIME")
|
|
return c
|
|
}
|
|
|
|
func (c Time) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|