func (this *Mirror) Run(args []string) (exitCode int) {
cmdFlags := flag.NewFlagSet("mirror", flag.ContinueOnError)
cmdFlags.Usage = func() { this.Ui.Output(this.Help()) }
cmdFlags.StringVar(&this.zone1, "z1", "", "")
cmdFlags.StringVar(&this.zone2, "z2", "", "")
cmdFlags.StringVar(&this.cluster1, "c1", "", "")
cmdFlags.StringVar(&this.cluster2, "c2", "", "")
cmdFlags.StringVar(&this.excludes, "excluded", "", "")
cmdFlags.BoolVar(&this.debug, "debug", false, "")
cmdFlags.StringVar(&this.compress, "compress", "", "")
cmdFlags.Int64Var(&this.bandwidthLimit, "net", 100, "")
cmdFlags.BoolVar(&this.autoCommit, "commit", true, "")
cmdFlags.Int64Var(&this.progressStep, "step", 5000, "")
if err := cmdFlags.Parse(args); err != nil {
return 1
}
if validateArgs(this, this.Ui).
require("-z1", "-z2", "-c1", "-c2").
invalid(args) {
return 2
}
this.topicsExcluded = make(map[string]struct{})
for _, e := range strings.Split(this.excludes, ",") {
this.topicsExcluded[e] = struct{}{}
}
log.SetOutput(os.Stdout)
this.quit = make(chan struct{})
limit := (1 << 20) * this.bandwidthLimit / 8
this.bandwidthRateLimiter = ratelimiter.NewLeakyBucket(limit, time.Second)
log.Printf("[%s]%s -> [%s]%s with bandwidth %sbps",
this.zone1, this.cluster1,
this.zone2, this.cluster2,
gofmt.Comma(int64(limit*8)))
signal.RegisterSignalsHandler(func(sig os.Signal) {
log.Printf("received signal: %s", strings.ToUpper(sig.String()))
log.Println("quiting...")
this.once.Do(func() {
close(this.quit)
})
}, syscall.SIGINT, syscall.SIGTERM)
z1 := zk.NewZkZone(zk.DefaultConfig(this.zone1, ctx.ZoneZkAddrs(this.zone1)))
z2 := zk.NewZkZone(zk.DefaultConfig(this.zone2, ctx.ZoneZkAddrs(this.zone2)))
c1 := z1.NewCluster(this.cluster1)
c2 := z2.NewCluster(this.cluster2)
this.makeMirror(c1, c2)
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.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 *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 *Gateway) Start() (err error) {
log.Trace("starting gateway...")
signal.RegisterSignalsHandler(func(sig os.Signal) {
log.Info("received signal: %s", strings.ToUpper(sig.String()))
this.stop()
}, syscall.SIGINT, syscall.SIGTERM) // yes we ignore HUP
meta.Default.Start()
log.Trace("meta store[%s] started", meta.Default.Name())
if err = manager.Default.Start(); err != nil {
return
}
log.Trace("manager store[%s] started", manager.Default.Name())
go this.watchDeadPartitions()
go this.guard.Start()
log.Trace("guard started")
if Options.EnableAccessLog {
if err = this.accessLogger.Start(); err != nil {
log.Error("access logger: %s", err)
}
}
this.buildRouting()
if Options.DebugHttpAddr != "" {
log.Info("debug http server ready on %s", Options.DebugHttpAddr)
go http.ListenAndServe(Options.DebugHttpAddr, nil)
}
this.svrMetrics.Load()
go startRuntimeMetrics(Options.ReporterInterval)
// start up the servers
if this.manServer != nil {
this.manServer.Start()
}
if this.pubServer != nil {
if err := store.DefaultPubStore.Start(); err != nil {
panic(err)
}
log.Trace("pub store[%s] started", store.DefaultPubStore.Name())
this.pubServer.Start()
}
if this.subServer != nil {
if err := store.DefaultSubStore.Start(); err != nil {
panic(err)
}
log.Trace("sub store[%s] started", store.DefaultSubStore.Name())
this.subServer.Start()
}
// the last thing is to register: notify others: come on baby!
if registry.Default != nil {
if err := registry.Default.Register(); err != nil {
panic(err)
}
log.Info("gateway[%s:%s] ready, registered in %s", ctx.Hostname(), this.id,
registry.Default.Name())
} else {
log.Info("gateway[%s:%s] ready, unregistered", ctx.Hostname(), this.id)
}
return nil
}
