func (this *Mirror) Main() (exitCode int) {
this.quit = make(chan struct{})
signal.RegisterHandler(func(sig os.Signal) {
log.Info("received signal: %s", strings.ToUpper(sig.String()))
log.Info("quiting...")
this.once.Do(func() {
close(this.quit)
})
}, syscall.SIGINT, syscall.SIGTERM)
limit := (1 << 20) * this.BandwidthLimit / 8
if this.BandwidthLimit > 0 {
this.bandwidthRateLimiter = ratelimiter.NewLeakyBucket(limit*10, time.Second*10)
}
log.Info("starting mirror@%s", gafka.BuildId)
// pprof
debugAddr := ":10009"
go http.ListenAndServe(debugAddr, nil)
log.Info("pprof ready on %s", debugAddr)
z1 := zk.NewZkZone(zk.DefaultConfig(this.Z1, ctx.ZoneZkAddrs(this.Z1)))
z2 := zk.NewZkZone(zk.DefaultConfig(this.Z2, ctx.ZoneZkAddrs(this.Z2)))
c1 := z1.NewCluster(this.C1)
c2 := z2.NewCluster(this.C2)
this.runMirror(c1, c2, limit)
log.Info("bye mirror@%s, %s", gafka.BuildId, time.Since(this.startedAt))
log.Close()
return
}
func main() {
for _, arg := range os.Args[1:] {
if arg == "-v" || arg == "-version" {
fmt.Fprintf(os.Stderr, "%s-%s\n", gafka.Version, gafka.BuildId)
return
}
}
t0 := time.Now()
bootstrap.Main()
log.Info("actord[%s@%s] %s, bye!", gafka.BuildId, gafka.BuiltAt, time.Since(t0))
log.Close()
}
func main() {
go http.ListenAndServe("localhost:6786", nil)
log.Info("pprof ready on http://localhost:6786/debug/pprof")
cfg := disk.DefaultConfig()
cfg.Dirs = []string{"hh"}
s := disk.New(cfg)
if err := s.Start(); err != nil {
panic(err)
}
placeholder := strings.Repeat(".", 1<<10)
i, j := 5, 1000
cluster, topic := "me", "app1.foobar.v1"
var wg sync.WaitGroup
for seq := 0; seq < i; seq++ {
wg.Add(1)
go func(seq int) {
defer wg.Done()
for loops := 0; loops < j; loops++ {
if err := s.Append(cluster, topic, []byte("key"),
[]byte(fmt.Sprintf("<#%d/%d sent at: %s %s>", seq, loops+1, time.Now(), placeholder))); err != nil {
panic(err)
}
}
}(seq)
}
log.Info("%d sent, waiting Append finish...", i*j)
wg.Wait()
log.Info("all Append done")
s.Stop()
log.Info("service stopped")
log.Info("Did you see %d messages? Inflight empty: %v", i*j, s.Empty(cluster, topic))
log.Info("bye!")
s.FlushInflights()
log.Close()
}
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 main() {
defer func() {
if err := recover(); err != nil {
fmt.Println(err)
debug.PrintStack()
}
}()
if gateway.Options.Debug {
log.SetFlags(log.LstdFlags | log.Llongfile) // TODO zk sdk uses this
log.SetPrefix(color.Magenta("[log]"))
} else {
log.SetOutput(ioutil.Discard)
}
if gateway.Options.KillFile != "" {
if err := signal.SignalProcessByPidFile(gateway.Options.KillFile, syscall.SIGUSR2); err != nil {
panic(err)
}
fmt.Println("kateway killed")
os.Exit(0)
}
if gateway.Options.GolangTrace {
// go tool trace kateway xxx.pprof
f, err := os.Create(time.Now().Format("2006-01-02T150405.pprof"))
if err != nil {
panic(err)
}
defer f.Close()
if err = trace.Start(f); err != nil {
panic(err)
}
defer trace.Stop()
}
fmt.Fprintln(os.Stderr, strings.TrimSpace(logo))
if gateway.Options.PidFile != "" {
pid := os.Getpid()
if err := ioutil.WriteFile(gateway.Options.PidFile, []byte(fmt.Sprintf("%d", pid)), 0644); err != nil {
panic(err)
}
}
gateway.SetupLogging(gateway.Options.LogFile, gateway.Options.LogLevel, gateway.Options.CrashLogFile)
// load config
if gateway.Options.ConfigFile == "" {
ctx.LoadFromHome()
} else {
_, err := os.Stat(gateway.Options.ConfigFile)
if err != nil {
panic(err)
}
ctx.LoadConfig(gateway.Options.ConfigFile)
}
gw := gateway.New(gateway.Options.Id)
if err := gw.Start(); err != nil {
glog.Error(err.Error())
glog.Info("kateway[%s@%s] bye!", gafka.BuildId, gafka.BuiltAt)
glog.Close()
os.Exit(1)
}
t0 := time.Now()
gw.ServeForever()
glog.Info("kateway[%s@%s] %s, bye!", gafka.BuildId, gafka.BuiltAt, time.Since(t0))
glog.Close()
if gateway.Options.PidFile != "" {
syscall.Unlink(gateway.Options.PidFile)
}
}
func (this *Monitor) ServeForever() {
defer this.zkzone.Close()
this.startedAt = time.Now()
log.Info("kguard[%s@%s] starting...", gafka.BuildId, gafka.BuiltAt)
signal.RegisterHandler(func(sig os.Signal) {
log.Info("kguard[%s@%s] received signal: %s", gafka.BuildId, gafka.BuiltAt, strings.ToUpper(sig.String()))
this.Stop()
close(this.quit)
}, syscall.SIGINT, syscall.SIGTERM)
// start the api server
apiServer := &http.Server{
Addr: this.apiAddr,
Handler: this.router,
}
apiListener, err := net.Listen("tcp4", this.apiAddr)
if err == nil {
log.Info("api http server ready on %s", this.apiAddr)
go apiServer.Serve(apiListener)
} else {
panic(fmt.Sprintf("api http server: %v", err))
}
backend, err := zookeeper.New(this.zkzone.ZkAddrList(), &store.Config{})
if err != nil {
panic(err)
}
ip, _ := ctx.LocalIP()
this.candidate = leadership.NewCandidate(backend, zk.KguardLeaderPath, ip.String(), 25*time.Second)
electedCh, errCh := this.candidate.RunForElection()
if err != nil {
panic("Cannot run for election, store is probably down")
}
for {
select {
case isElected := <-electedCh:
if isElected {
log.Info("Won the election, starting all watchers")
this.Start()
} else {
log.Warn("Fails the election, watching election events...")
this.Stop()
}
case err := <-errCh:
if err != nil {
log.Error("Error during election: %v", err)
}
case <-this.quit:
apiListener.Close()
log.Info("api http server closed")
log.Info("kguard[%s@%s] bye!", gafka.BuildId, gafka.BuiltAt)
log.Close()
return
}
}
}