func (this *Start) Help() string {
help := fmt.Sprintf(`
Usage: %s start [options]
Start %s system on localhost
Options:
-z zone
Default %s
-forwardfor
Default false.
If true, haproxy will add X-Forwarded-For http header.
-pub pub server listen port
-sub sub server listen port
-man manager server listen port
-p directory prefix
Default %s
-log log file
Default %s
`, this.Cmd, this.Cmd, ctx.ZkDefaultZone(), defaultPrefix, defaultLogfile)
return strings.TrimSpace(help)
}
func (this *TopBroker) Help() string {
help := fmt.Sprintf(`
Usage: %s topbroker [options]
Unix “top” like utility for kafka brokers
Options:
-z zone
Default %s
-c cluster pattern
-t topic pattern
-i interval
Refresh interval in seconds.
e,g. 5s
-shortip
Print ending portion of broker ip address.
`, this.Cmd, ctx.ZkDefaultZone())
return strings.TrimSpace(help)
}
func (this *Stat) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("stat", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
if this.zone == "" {
this.Ui.Error("unknown zone")
return 2
}
if len(args) == 0 {
this.Ui.Error("missing path")
return 2
}
this.path = args[len(args)-1]
zkzone := gzk.NewZkZone(gzk.DefaultConfig(this.zone, ctx.ZoneZkAddrs(this.zone)))
defer zkzone.Close()
conn := zkzone.Conn()
_, stat, err := conn.Get(this.path)
must(err)
this.Ui.Output(fmt.Sprintf("%# v", pretty.Formatter(*stat)))
ctime := gzk.ZkTimestamp(stat.Ctime).Time()
mtime := gzk.ZkTimestamp(stat.Mtime).Time()
this.Ui.Output(fmt.Sprintf("ctime: %s, mtime: %s",
gofmt.PrettySince(ctime), gofmt.PrettySince(mtime)))
return
}
func (this *Topology) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("topology", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&this.cluster, "c", "", "")
cmdFlags.StringVar(&this.hostPattern, "host", "", "")
cmdFlags.BoolVar(&this.verbose, "l", false, "")
cmdFlags.BoolVar(&this.watchMode, "w", false, "")
cmdFlags.BoolVar(&this.maxPort, "maxport", false, "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
// a single zone
ensureZoneValid(this.zone)
zkzone := zk.NewZkZone(zk.DefaultConfig(this.zone, ctx.ZoneZkAddrs(this.zone)))
for {
if this.maxPort {
this.displayZoneMaxPort(zkzone)
} else {
this.displayZoneTopology(zkzone)
}
if !this.watchMode {
return
}
time.Sleep(time.Second * 5)
refreshScreen()
}
return
}
func (this *Kguard) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("kguard", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.BoolVar(&this.longFmt, "l", false, "")
if err := cmdFlags.Parse(args); err != nil {
return 2
}
zkzone := zk.NewZkZone(zk.DefaultConfig(this.zone, ctx.ZoneZkAddrs(this.zone)))
kguards, err := zkzone.KguardInfos()
if err != nil {
this.Ui.Error(fmt.Sprintf("%s %v", zk.KguardLeaderPath, err.Error()))
return
}
leader := kguards[0]
this.Ui.Output(fmt.Sprintf("%s(out of %d candidates) up: %s",
color.Green(leader.Host), leader.Candidates,
gofmt.PrettySince(leader.Ctime)))
if this.longFmt {
this.showKguardVersion(leader.Host)
this.showStats(leader.Host)
}
return
}
func (this *Zones) Run(args []string) (exitCode int) {
// header
this.Ui.Output(fmt.Sprintf("%10s %-70s", "zone", "zookeeper ensemble"))
this.Ui.Output(fmt.Sprintf("%s %s",
strings.Repeat("-", 10),
strings.Repeat("-", 70)))
if len(args) > 0 {
// user specified the zones to print
for _, zone := range args {
if zk, present := ctx.Zones()[zone]; present {
this.Ui.Output(fmt.Sprintf("%10s %s", zone, zk))
} else {
this.Ui.Output(fmt.Sprintf("%10s not defined", zone))
}
}
return
}
// print all by default
defaultZone := ctx.ZkDefaultZone()
for _, zone := range ctx.SortedZones() {
if defaultZone == zone {
this.Ui.Output(fmt.Sprintf("%10s %s", zone+"*", ctx.ZoneZkAddrs(zone)))
continue
}
this.Ui.Output(fmt.Sprintf("%10s %s", zone, ctx.ZoneZkAddrs(zone)))
}
return
}
func (this *Mount) Help() string {
help := fmt.Sprintf(`
Usage: %s mount [options] mount_point
%s
Pre-requisites:
yum install -y fuse
modprobe fuse
lsmod | grep fuse
Options:
-z zone
Default '%s'.
-c cluster
-l log level
Default 'info'.
`, this.Cmd, this.Synopsis(), ctx.ZkDefaultZone())
return strings.TrimSpace(help)
}
func (this *Lags) Help() string {
help := fmt.Sprintf(`
Usage: %s lags [options]
Display online high level consumers lag on a topic
Options:
-z zone
Default %s
-c cluster
-g group name pattern
-t topic name pattern
-w
Watch mode. Keep printing out lags with 60s interval refresh.
-l
Only show online consumers lag.
-lag threshold
Default 5000.
-p
Only show problematic consumers.
-table
Display in table format.
`, this.Cmd, ctx.ZkDefaultZone())
return strings.TrimSpace(help)
}
// TODO run 3 nodes in a zone to monitor as daemon
// register the 3 nodes as host service tag.
func (this *Ping) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("ping", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.DurationVar(&this.interval, "interval", time.Minute*5, "")
cmdFlags.StringVar(&this.logfile, "logfile", "stdout", "")
cmdFlags.BoolVar(&this.problematicMode, "p", false, "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
this.setupLog()
this.zkzone = zk.NewZkZone(zk.DefaultConfig(this.zone, ctx.ZoneZkAddrs(this.zone)))
for {
this.diagnose()
if this.logfile == "stdout" {
break
}
time.Sleep(this.interval)
}
return
}
func (this *Create) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("create", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&this.path, "p", "", "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
if validateArgs(this, this.Ui).
require("-p").
requireAdminRights("-p").
invalid(args) {
return 2
}
if this.zone == "" {
this.Ui.Error("unknown zone")
return 2
}
zkzone := gzk.NewZkZone(gzk.DefaultConfig(this.zone, ctx.ZoneZkAddrs(this.zone)))
defer zkzone.Close()
conn := zkzone.Conn()
data := inData()
flags := int32(0)
acl := zk.WorldACL(zk.PermAll)
_, err := conn.Create(this.path, data, flags, acl)
must(err)
return
}
func (this *Consumers) Run(args []string) (exitCode int) {
var (
cluster string
zone string
)
cmdFlags := flag.NewFlagSet("consumers", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&cluster, "c", "", "")
cmdFlags.StringVar(&this.groupPattern, "g", "", "")
cmdFlags.BoolVar(&this.onlineOnly, "online", false, "")
cmdFlags.BoolVar(&this.byHost, "byhost", false, "")
cmdFlags.StringVar(&this.topicPattern, "t", "", "")
cmdFlags.BoolVar(&this.warnOnly, "warn", false, "")
cmdFlags.BoolVar(&this.ownerOnly, "own", false, "")
cmdFlags.BoolVar(&this.cleanup, "cleanup", false, "")
cmdFlags.BoolVar(&this.confirmYes, "yes", false, "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
if validateArgs(this, this.Ui).
requireAdminRights("-cleanup").
invalid(args) {
return 2
}
if this.ownerOnly {
this.onlineOnly = true
}
if zone == "" {
forSortedZones(func(zkzone *zk.ZkZone) {
switch {
case this.cleanup:
this.cleanupStaleConsumerGroups(zkzone, cluster)
case this.byHost:
this.printConsumersByHost(zkzone, cluster)
default:
this.printConsumersByGroupTable(zkzone, cluster)
}
})
return
}
zkzone := zk.NewZkZone(zk.DefaultConfig(zone, ctx.ZoneZkAddrs(zone)))
switch {
case this.cleanup:
this.cleanupStaleConsumerGroups(zkzone, cluster)
case this.byHost:
this.printConsumersByHost(zkzone, cluster)
default:
this.printConsumersByGroupTable(zkzone, cluster)
}
return
}
func (this *Peek) Help() string {
help := fmt.Sprintf(`
Usage: %s peek [options]
%s
Options:
-z zone
Default %s
-c cluster
-t topic pattern
-p partition id
-1 will peek all partitions of a topic
-beep
Make a beep sound for each message
-pretty
Pretty print the json message body
-col json column name
Will json decode message and extract specified column value only
-last n
Peek the most recent N messages
-offset message offset value
-1 OffsetNewest, -2 OffsetOldest.
You can specify your own offset.
Default -1(OffsetNewest)
-n count
Limit how many messages to consume
-d duration
Limit how long to keep peeking
e,g. -d 5m
-body
Only display message body
-s
Silence mode, only display statastics instead of message content
-color
Enable colorized output
`, this.Cmd, this.Synopsis(), ctx.ZkDefaultZone())
return strings.TrimSpace(help)
}
func (this *Zones) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("zones", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.BoolVar(&this.ipInNumber, "n", false, "")
cmdFlags.BoolVar(&this.plain, "plain", false, "")
if err := cmdFlags.Parse(args); err != nil {
return 2
}
// print all by default
zones := make([][]string, 0)
defaultZone := ctx.ZkDefaultZone()
for _, zone := range ctx.SortedZones() {
if defaultZone == zone {
if this.ipInNumber {
zones = append(zones, []string{zone + "*", ctx.ZoneZkAddrs(zone)})
} else {
zones = append(zones, []string{zone + "*", ctx.NamedZoneZkAddrs(zone)})
}
continue
}
if this.ipInNumber {
zones = append(zones, []string{zone, ctx.ZoneZkAddrs(zone)})
} else {
zones = append(zones, []string{zone, ctx.NamedZoneZkAddrs(zone)})
}
}
if this.plain {
for _, z := range zones {
this.Ui.Output(fmt.Sprintf("%s:", z[0]))
this.Ui.Output(fmt.Sprintf("%s\n", z[1]))
}
return
}
table := tablewriter.NewWriter(os.Stdout)
for _, z := range zones {
table.Append(z)
}
table.SetHeader([]string{"Zone", "ZK ensemble"})
table.SetFooter([]string{"Total", fmt.Sprintf("%d", len(zones))})
table.Render() // Send output
return
}
func (this *Offset) Run(args []string) (exitCode int) {
var (
zone string
cluster string
topic string
group string
partition string
offset int64
)
cmdFlags := flag.NewFlagSet("offset", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&cluster, "c", "", "")
cmdFlags.StringVar(&topic, "t", "", "")
cmdFlags.StringVar(&group, "g", "", "")
cmdFlags.Int64Var(&offset, "offset", -1, "")
cmdFlags.StringVar(&partition, "p", "", "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
if validateArgs(this, this.Ui).
require("-z", "-c", "-t", "-g", "-p", "-offset").
requireAdminRights("-z").
invalid(args) {
return 2
}
if offset < 0 {
this.Ui.Error("offset must be positive")
return
}
if p, err := strconv.Atoi(partition); err != nil {
this.Ui.Error("invalid partition")
return
} else if p < 0 || p > 100 {
this.Ui.Error("invalid partition")
return
}
zkzone := zk.NewZkZone(zk.DefaultConfig(zone, ctx.ZoneZkAddrs(zone)))
zkcluster := zkzone.NewCluster(cluster)
zkcluster.ResetConsumerGroupOffset(topic, group, partition, offset)
this.Ui.Output("done")
return
}
func (this *Rm) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("rm", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&this.path, "p", "", "")
cmdFlags.BoolVar(&this.recursive, "R", false, "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
if validateArgs(this, this.Ui).
require("-p").
requireAdminRights("-p").
invalid(args) {
return 2
}
if this.zone == "" {
this.Ui.Error("unknown zone")
return 2
}
zkzone := gzk.NewZkZone(gzk.DefaultConfig(this.zone, ctx.ZoneZkAddrs(this.zone)))
defer zkzone.Close()
if this.recursive {
err := zkzone.DeleteRecursive(this.path)
if err != nil {
this.Ui.Error(err.Error())
} else {
this.Ui.Info(fmt.Sprintf("%s deleted ok", this.path))
}
return 0
}
// remove a single znode
conn := zkzone.Conn()
err := conn.Delete(this.path, -1)
if err != nil {
this.Ui.Error(err.Error())
} else {
this.Ui.Info(fmt.Sprintf("%s deleted ok", this.path))
}
return
}
func (this *LsZk) Help() string {
help := fmt.Sprintf(`
Usage: %s lszk [options] <path>
List kafka related zookeepeer znode children
Options:
-z zone
Default %s
-c cluster
-R
recursive.
`, this.Cmd, ctx.ZkDefaultZone())
return strings.TrimSpace(help)
}
func (this *Ls) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("ls", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.BoolVar(&this.recursive, "R", false, "")
cmdFlags.StringVar(&this.likePattern, "like", "", "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
if len(args) == 0 {
this.Ui.Error("missing path")
return 2
}
this.path = args[len(args)-1]
if this.zone == "" {
this.Ui.Error("unknown zone")
return 2
}
zkzone := gzk.NewZkZone(gzk.DefaultConfig(this.zone, ctx.ZoneZkAddrs(this.zone)))
defer zkzone.Close()
conn := zkzone.Conn()
if this.recursive {
this.showChildrenRecursively(conn, this.path)
return
}
children, _, err := conn.Children(this.path)
must(err)
sort.Strings(children)
if this.path == "/" {
this.path = ""
}
for _, child := range children {
this.Ui.Output(this.path + "/" + child)
}
return
}
func (this *LsZk) Help() string {
help := fmt.Sprintf(`
Usage: %s lszk [options] <path>
%s
Options:
-z zone
Default %s
-c cluster
-R
recursive.
`, this.Cmd, this.Synopsis(), ctx.ZkDefaultZone())
return strings.TrimSpace(help)
}
func (this *Brokers) Run(args []string) (exitCode int) {
var (
zone string
debug bool
)
cmdFlags := flag.NewFlagSet("brokers", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&this.cluster, "c", "", "")
cmdFlags.BoolVar(&debug, "debug", false, "")
cmdFlags.BoolVar(&this.ipInNumber, "n", false, "")
cmdFlags.BoolVar(&this.staleOnly, "stale", false, "")
cmdFlags.BoolVar(&this.showVersions, "versions", false, "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
if this.showVersions {
this.doShowVersions()
return
}
if debug {
sarama.Logger = log.New(os.Stderr, color.Magenta("[sarama]"), log.LstdFlags)
}
if zone != "" {
ensureZoneValid(zone)
zkzone := zk.NewZkZone(zk.DefaultConfig(zone, ctx.ZoneZkAddrs(zone)))
this.displayZoneBrokers(zkzone)
return
}
// print all brokers on all zones by default
forSortedZones(func(zkzone *zk.ZkZone) {
this.displayZoneBrokers(zkzone)
})
return
}
func (this *Top) Help() string {
help := fmt.Sprintf(`
Usage: %s top [options]
%s
Options:
-z zone
Default %s
-c cluster pattern
-t topic pattern
-i interval
Refresh interval in seconds.
e,g. 5s
-n limit
-l
Display long format. Print broker host.
-shortip
Used with -l, broker host 10.20.30.40 will display as 30.40
-d
Draw dashboard in graph.
-for duration
Run top for how long.
-b
Batch mode operation.
Could be useful for sending output from top to other programs or to a file.
-who <%s%s|%s%s>
`, this.Cmd, this.Synopsis(), ctx.ZkDefaultZone(), color.Colorize([]string{color.Underscore}, "p"), "roducer",
color.Colorize([]string{color.Underscore}, "c"), "onsumer")
return strings.TrimSpace(help)
}
func (this *Start) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("start", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.logfile, "log", defaultLogfile, "")
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&this.root, "p", defaultPrefix, "")
cmdFlags.BoolVar(&this.forwardFor, "forwardfor", false, "")
cmdFlags.IntVar(&this.pubPort, "pub", 10891, "")
cmdFlags.IntVar(&this.subPort, "sub", 10892, "")
cmdFlags.IntVar(&this.manPort, "man", 10893, "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
err := os.Chdir(this.root)
swalllow(err)
this.command = fmt.Sprintf("%s/sbin/haproxy", this.root)
if _, err := os.Stat(this.command); err != nil {
panic(err)
}
this.setupLogging(this.logfile, "info", "panic")
this.starting = true
this.quitCh = make(chan struct{})
signal.RegisterSignalsHandler(func(sig os.Signal) {
log.Info("got signal %s", sig)
this.shutdown()
log.Info("removing %s", configFile)
os.Remove(configFile)
log.Info("shutdown complete")
}, syscall.SIGINT, syscall.SIGTERM)
this.main()
return
}
func (this *LsZk) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("lszk", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&this.cluster, "c", "", "")
cmdFlags.BoolVar(&this.recursive, "R", false, "")
if err := cmdFlags.Parse(args); err != nil {
return 2
}
zkzone := zk.NewZkZone(zk.DefaultConfig(this.zone, ctx.ZoneZkAddrs(this.zone)))
if this.cluster != "" {
zkcluster := zkzone.NewCluster(this.cluster)
this.printCluster(zkcluster)
} else {
zkzone.ForSortedClusters(func(zkcluster *zk.ZkCluster) {
this.printCluster(zkcluster)
})
}
return
}
func (this *Verify) Help() string {
help := fmt.Sprintf(`
Usage: %s verify [options]
%s
Options:
-z zone
Default %s
-c cluster
-mode <p|s|t>
-go
Confirmed to update KafkaTopicName in table topics.
`, this.Cmd, this.Synopsis(), ctx.ZkDefaultZone())
return strings.TrimSpace(help)
}
func (this *Verify) Help() string {
help := fmt.Sprintf(`
Usage: %s verify [options]
Verify pubsub clients synced with lagacy kafka
Options:
-z zone
Default %s
-c cluster
-mode <p|s|t>
-go
Confirmed to update KafkaTopicName in table topics.
`, this.Cmd, ctx.ZkDefaultZone())
return strings.TrimSpace(help)
}
func (this *Import) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("import", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&this.path, "p", "", "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
if validateArgs(this, this.Ui).
require("-p").
requireAdminRights("-p").
invalid(args) {
return 2
}
if this.zone == "" {
this.Ui.Error("unknown zone")
return 2
}
return
}
func (this *Agent) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("start", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.logfile, "log", "stdout", "")
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.BoolVar(&this.debug, "debug", false, "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
this.starting = true
this.quitCh = make(chan struct{})
timeout := time.Second * 4
this.callbackConn = &http.Client{
Timeout: timeout,
Transport: &http.Transport{
MaxIdleConnsPerHost: 5,
Proxy: http.ProxyFromEnvironment,
Dial: (&net.Dialer{
Timeout: timeout,
}).Dial,
DisableKeepAlives: false, // enable http conn reuse
ResponseHeaderTimeout: timeout,
TLSHandshakeTimeout: timeout,
},
}
signal.RegisterSignalsHandler(func(sig os.Signal) {
log.Info("got signal %s", sig)
this.shutdown()
log.Info("shutdown complete")
}, syscall.SIGINT, syscall.SIGTERM)
this.main()
return
}
func (this *TopBroker) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("topbroker", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&this.cluster, "c", "", "")
cmdFlags.StringVar(&this.topic, "t", "", "")
cmdFlags.BoolVar(&this.shortIp, "shortip", false, "")
cmdFlags.DurationVar(&this.interval, "i", time.Second*5, "refresh interval")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
this.signalsCh = make(map[string]chan struct{})
this.hostOffsetCh = make(chan map[string]int64)
this.offsets = make(map[string]int64)
this.lastOffsets = make(map[string]int64)
if this.interval.Seconds() < 1 {
this.interval = time.Second
}
zkzone := zk.NewZkZone(zk.DefaultConfig(this.zone, ctx.ZoneZkAddrs(this.zone)))
zkzone.ForSortedClusters(func(zkcluster *zk.ZkCluster) {
if !patternMatched(zkcluster.Name(), this.cluster) {
return
}
this.signalsCh[zkcluster.Name()] = make(chan struct{})
go this.clusterTopProducers(zkcluster)
})
this.drawDashboard()
return
}
func (this *Acl) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("acl", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
if this.zone == "" {
this.Ui.Error("unknown zone")
return 2
}
this.path = args[len(args)-1]
zkzone := gzk.NewZkZone(gzk.DefaultConfig(this.zone, ctx.ZoneZkAddrs(this.zone)))
defer zkzone.Close()
conn := zkzone.Conn()
acls, _, err := conn.GetACL(this.path)
must(err)
this.Ui.Output(fmt.Sprintf("%# v", pretty.Formatter(acls)))
return
}
func (this *Start) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("start", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.logfile, "log", defaultLogfile, "")
cmdFlags.StringVar(&this.zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&this.root, "p", defaultPrefix, "")
cmdFlags.BoolVar(&this.debugMode, "d", false, "")
cmdFlags.BoolVar(&this.forwardFor, "forwardfor", false, "")
cmdFlags.IntVar(&this.pubPort, "pub", 10891, "")
cmdFlags.IntVar(&this.subPort, "sub", 10892, "")
cmdFlags.IntVar(&this.manPort, "man", 10893, "")
cmdFlags.StringVar(&this.haproxyStatsUrl, "statsurl", "", "")
cmdFlags.StringVar(&this.influxdbAddr, "influxaddr", "", "")
cmdFlags.StringVar(&this.influxdbDbName, "influxdb", "", "")
cmdFlags.StringVar(&this.httpAddr, "addr", ":10894", "monitor http server addr")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
lockFilename := fmt.Sprintf("%s/.lock", this.root)
if locking.InstanceLocked(lockFilename) {
panic(fmt.Sprintf("locked[%s] by another instance", lockFilename))
}
locking.LockInstance(lockFilename)
err := os.Chdir(this.root)
swalllow(err)
this.command = fmt.Sprintf("%s/sbin/haproxy", this.root)
if _, err := os.Stat(this.command); err != nil {
panic(err)
}
this.setupLogging(this.logfile, "info", "panic")
this.starting = true
this.startedAt = time.Now()
if this.haproxyStatsUrl != "" &&
this.influxdbAddr != "" && this.influxdbDbName != "" {
rc, err := influxdb.NewConfig(this.influxdbAddr, this.influxdbDbName, "", "", time.Minute)
if err != nil {
panic(err)
}
telemetry.Default = influxdb.New(metrics.DefaultRegistry, rc)
go func() {
log.Info("telemetry started: %s", telemetry.Default.Name())
if err := telemetry.Default.Start(); err != nil {
log.Error("telemetry: %v", err)
}
}()
m := haproxyMetrics{
ctx: this,
interval: time.Second * 30,
uri: this.haproxyStatsUrl,
}
go m.start()
}
this.quitCh = make(chan struct{})
this.closed = make(chan struct{})
signal.RegisterHandler(func(sig os.Signal) {
log.Info("ehaproxy[%s] got signal: %s", gafka.BuildId, strings.ToUpper(sig.String()))
this.shutdown()
log.Info("removing %s", configFile)
os.Remove(configFile)
log.Info("removing lock[%s]", lockFilename)
locking.UnlockInstance(lockFilename)
close(this.quitCh)
if telemetry.Default != nil {
log.Info("stopping telemetry and flush all metrics...")
telemetry.Default.Stop()
}
log.Info("ehaproxy[%s] shutdown complete", gafka.BuildId)
log.Info("ehaproxy[%s] %s bye!", gafka.BuildId, time.Since(this.startedAt))
close(this.closed)
}, syscall.SIGINT, syscall.SIGTERM)
this.main()
<-this.closed
log.Close()
return
}
func (this *Clusters) Run(args []string) (exitCode int) {
var (
addCluster string
setMode bool
verifyMode bool
public int
clusterName string
clusterPath string
zone string
priority int
retentionHours int
port string
delCluster string
replicas int
addBroker string
nickname string
delBroker string
summaryMode bool
)
cmdFlags := flag.NewFlagSet("clusters", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&zone, "z", ctx.ZkDefaultZone(), "")
cmdFlags.StringVar(&addCluster, "add", "", "")
cmdFlags.BoolVar(&this.publicOnly, "po", false, "")
cmdFlags.BoolVar(&setMode, "s", false, "")
cmdFlags.StringVar(&clusterName, "c", "", "")
cmdFlags.StringVar(&clusterPath, "p", "", "")
cmdFlags.BoolVar(&this.verbose, "l", false, "")
cmdFlags.IntVar(&replicas, "replicas", -1, "")
cmdFlags.StringVar(&delCluster, "del", "", "")
cmdFlags.BoolVar(&summaryMode, "sum", false, "")
cmdFlags.BoolVar(&this.neat, "neat", false, "")
cmdFlags.IntVar(&retentionHours, "retention", -1, "")
cmdFlags.IntVar(&priority, "priority", -1, "")
cmdFlags.IntVar(&public, "public", -1, "")
cmdFlags.BoolVar(&this.ipInNumber, "n", false, "")
cmdFlags.StringVar(&port, "port", "", "")
cmdFlags.StringVar(&addBroker, "addbroker", "", "")
cmdFlags.StringVar(&nickname, "nickname", "", "")
cmdFlags.StringVar(&delBroker, "delbroker", "", "")
cmdFlags.BoolVar(&this.registeredBrokers, "registered", false, "")
cmdFlags.BoolVar(&verifyMode, "verify", false, "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
if validateArgs(this, this.Ui).
on("-add", "-z", "-p").
on("-s", "-z", "-c").
requireAdminRights("-s", "-add").
invalid(args) {
return 2
}
if this.publicOnly {
this.verbose = true
}
if delCluster != "" {
zkzone := zk.NewZkZone(zk.DefaultConfig(zone, ctx.ZoneZkAddrs(zone)))
zkcluster := zkzone.NewCluster(delCluster)
kfkCluseterPath := zkzone.ClusterPath(delCluster)
gafkaClusterInfoPath := zkcluster.ClusterInfoPath()
gafkaClusterPath := zk.ClusterPath(delCluster)
this.Ui.Info("shutdown brokers first: kill java/rm pkg/chkconfig --del")
this.Ui.Info(fmt.Sprintf("zk rm -z %s -R -p %s",
zone, kfkCluseterPath))
this.Ui.Info(fmt.Sprintf("zk rm -z %s -p %s",
zone, gafkaClusterPath))
this.Ui.Info(fmt.Sprintf("zk rm -z %s -p %s",
zone, gafkaClusterInfoPath))
return
}
if addCluster != "" {
// add cluster
zkzone := zk.NewZkZone(zk.DefaultConfig(zone, ctx.ZoneZkAddrs(zone)))
defer printSwallowedErrors(this.Ui, zkzone)
if err := zkzone.RegisterCluster(addCluster, clusterPath); err != nil {
this.Ui.Error(err.Error())
return 1
}
this.Ui.Info(fmt.Sprintf("%s: %s created", addCluster, clusterPath))
return
}
if setMode {
// setup a cluser meta info
zkzone := zk.NewZkZone(zk.DefaultConfig(zone, ctx.ZoneZkAddrs(zone)))
zkcluster := zkzone.NewCluster(clusterName)
if priority != -1 {
zkcluster.SetPriority(priority)
}
if public != -1 {
switch public {
case 0:
zkcluster.SetPublic(false)
case 1:
if nickname == "" {
this.Ui.Error("-nickname required if set public a cluster, quit.")
return
}
zkcluster.SetPublic(true)
}
}
if retentionHours != -1 {
zkcluster.SetRetention(retentionHours)
}
if replicas != -1 {
zkcluster.SetReplicas(replicas)
}
if nickname != "" {
zkcluster.SetNickname(nickname)
}
switch {
case addBroker != "":
parts := strings.Split(addBroker, ":")
if len(parts) != 3 {
this.Ui.Output(this.Help())
return
}
brokerId, err := strconv.Atoi(parts[0])
swallow(err)
port, err := strconv.Atoi(parts[2])
swallow(err)
swallow(zkcluster.RegisterBroker(brokerId, parts[1], port))
return
case delBroker != "":
for _, bid := range strings.Split(delBroker, ",") {
brokerId, err := strconv.Atoi(strings.TrimSpace(bid))
swallow(err)
swallow(zkcluster.UnregisterBroker(brokerId))
}
return
default:
return
}
}
if verifyMode {
if zone != "" {
zkzone := zk.NewZkZone(zk.DefaultConfig(zone, ctx.ZoneZkAddrs(zone)))
this.verifyBrokers(zkzone)
printSwallowedErrors(this.Ui, zkzone)
} else {
// print all zones all clusters
forSortedZones(func(zkzone *zk.ZkZone) {
this.verifyBrokers(zkzone)
printSwallowedErrors(this.Ui, zkzone)
})
}
return
}
if summaryMode {
zkzone := zk.NewZkZone(zk.DefaultConfig(zone, ctx.ZoneZkAddrs(zone)))
this.printSummary(zkzone, clusterName, port)
return
}
// display mode
if zone != "" {
zkzone := zk.NewZkZone(zk.DefaultConfig(zone, ctx.ZoneZkAddrs(zone)))
this.printClusters(zkzone, clusterName, port)
printSwallowedErrors(this.Ui, zkzone)
} else {
// print all zones all clusters
forSortedZones(func(zkzone *zk.ZkZone) {
this.printClusters(zkzone, clusterName, port)
printSwallowedErrors(this.Ui, zkzone)
})
}
return
}