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()
}
// Main is the bootstrap main entry point, which will run for ever.
func Main() {
defer func() {
if err := recover(); err != nil {
fmt.Println(err)
debug.PrintStack()
}
}()
var err error
zkzone := zk.NewZkZone(zk.DefaultConfig(Options.Zone, ctx.ZoneZkAddrs(Options.Zone)))
// meta pkg is required for store pkg
metaConf := zkmeta.DefaultConfig()
metaConf.Refresh = time.Minute * 5
meta.Default = zkmeta.New(metaConf, zkzone)
meta.Default.Start()
log.Trace("meta store[%s] started", meta.Default.Name())
if Options.InfluxAddr != "" && Options.InfluxDbname != "" {
rc, err := influxdb.NewConfig(Options.InfluxAddr, Options.InfluxDbname, "", "", time.Minute)
if err != nil {
panic(err)
}
telemetry.Default = influxdb.New(metrics.DefaultRegistry, rc)
go func() {
log.Info("telemetry[%s] started", telemetry.Default.Name())
if err := telemetry.Default.Start(); err != nil {
log.Error("telemetry[%s]: %v", telemetry.Default.Name(), err)
}
}()
} else {
log.Warn("empty influx flag, telemetry disabled")
}
store.DefaultPubStore = kafka.NewPubStore(100, 0, false, false, false)
if err = store.DefaultPubStore.Start(); err != nil {
panic(err)
}
log.Trace("pub store[%s] started", store.DefaultPubStore.Name())
c := controller.New(zkzone, Options.ListenAddr, Options.ManagerType)
cfg := disk.DefaultConfig()
cfg.Dirs = strings.Split(Options.HintedHandoffDir, ",")
if err := cfg.Validate(); err != nil {
panic(err)
}
disk.Auditor = c.Auditor()
hh.Default = disk.New(cfg)
if err = hh.Default.Start(); err != nil {
panic(err)
}
log.Trace("hh[%s] started", hh.Default.Name())
signal.RegisterHandler(func(sig os.Signal) {
log.Info("actord[%s@%s] received signal: %s", gafka.BuildId, gafka.BuiltAt, strings.ToUpper(sig.String()))
log.Trace("controller[%s] stopping...", c.Id())
c.Stop()
}, syscall.SIGINT, syscall.SIGTERM)
if err = c.RunForever(); err != nil {
panic(err)
}
log.Trace("pub store[%s] stopping", store.DefaultPubStore.Name())
store.DefaultPubStore.Stop()
meta.Default.Stop()
log.Trace("meta store[%s] stopped", meta.Default.Name())
if telemetry.Default != nil {
telemetry.Default.Stop()
log.Info("telemetry[%s] stopped", telemetry.Default.Name())
}
zkzone.Close()
log.Trace("zkzone stopped")
log.Trace("all cleanup done")
}
func New(id string) *Gateway {
this := &Gateway{
id: id,
shutdownCh: make(chan struct{}),
quiting: make(chan struct{}),
certFile: Options.CertFile,
keyFile: Options.KeyFile,
}
this.zkzone = gzk.NewZkZone(gzk.DefaultConfig(Options.Zone, ctx.ZoneZkAddrs(Options.Zone)))
if err := this.zkzone.Ping(); err != nil {
panic(err)
}
if Options.EnableRegistry {
registry.Default = zk.New(this.zkzone)
}
metaConf := zkmeta.DefaultConfig()
metaConf.Refresh = Options.MetaRefresh
meta.Default = zkmeta.New(metaConf, this.zkzone)
this.accessLogger = NewAccessLogger("access_log", 100)
this.svrMetrics = NewServerMetrics(Options.ReporterInterval, this)
rc, err := influxdb.NewConfig(Options.InfluxServer, Options.InfluxDbName, "", "", Options.ReporterInterval)
if err != nil {
log.Error("telemetry: %v", err)
} else {
telemetry.Default = influxdb.New(metrics.DefaultRegistry, rc)
}
// initialize the manager store
switch Options.ManagerStore {
case "mysql":
cf := mandb.DefaultConfig(Options.Zone)
cf.Refresh = Options.ManagerRefresh
manager.Default = mandb.New(cf)
manager.Default.AllowSubWithUnregisteredGroup(Options.PermitUnregisteredGroup)
case "dummy":
manager.Default = mandummy.New(Options.DummyCluster)
case "open":
cf := manopen.DefaultConfig(Options.Zone)
cf.Refresh = Options.ManagerRefresh
manager.Default = manopen.New(cf)
manager.Default.AllowSubWithUnregisteredGroup(Options.PermitUnregisteredGroup)
HttpHeaderAppid = "devid"
HttpHeaderPubkey = "devsecret"
HttpHeaderSubkey = "devsecret"
default:
panic("invalid manager store:" + Options.ManagerStore)
}
// initialize the servers on demand
if Options.DebugHttpAddr != "" {
this.debugMux = http.NewServeMux()
}
if Options.ManHttpAddr != "" || Options.ManHttpsAddr != "" {
this.manServer = newManServer(Options.ManHttpAddr, Options.ManHttpsAddr,
Options.MaxClients, this)
} else {
panic("manager server must be present")
}
if Options.PubHttpAddr != "" || Options.PubHttpsAddr != "" {
this.pubServer = newPubServer(Options.PubHttpAddr, Options.PubHttpsAddr,
Options.MaxClients, this)
switch Options.Store {
case "kafka":
store.DefaultPubStore = storekfk.NewPubStore(Options.PubPoolCapcity, Options.PubPoolIdleTimeout,
Options.UseCompress, Options.Debug, Options.DryRun)
case "dummy":
store.DefaultPubStore = storedummy.NewPubStore(Options.Debug)
default:
panic("invalid message store")
}
switch Options.JobStore {
case "mysql":
var mcc = &config.ConfigMysql{}
b, err := this.zkzone.KatewayJobClusterConfig()
if err != nil {
panic(err)
}
if err = mcc.From(b); err != nil {
panic(err)
}
jm, err := jobmysql.New(id, mcc)
if err != nil {
panic(fmt.Errorf("mysql job: %v", err))
}
job.Default = jm
case "dummy":
job.Default = jobdummy.New()
default:
panic("invalid job store")
}
// always create hh so that we can turn on/off it online
switch Options.HintedHandoffType {
case "disk":
if len(Options.HintedHandoffDir) == 0 {
panic("empty hh dir")
}
cfg := hhdisk.DefaultConfig()
cfg.Dirs = strings.Split(Options.HintedHandoffDir, ",")
if err := cfg.Validate(); err != nil {
panic(err)
}
hhdisk.DisableBufio = !Options.HintedHandoffBufio
if Options.AuditPub {
hhdisk.Auditor = &this.pubServer.auditor
}
hh.Default = hhdisk.New(cfg)
case "dummy":
hh.Default = hhdummy.New()
default:
panic("unkown hinted handoff type")
}
if Options.FlushHintedOffOnly {
meta.Default.Start()
log.Trace("meta store[%s] started", meta.Default.Name())
if err = store.DefaultPubStore.Start(); err != nil {
panic(err)
}
log.Trace("pub store[%s] started", store.DefaultPubStore.Name())
hh.Default.FlushInflights()
os.Exit(0)
}
}
if Options.SubHttpAddr != "" || Options.SubHttpsAddr != "" {
this.subServer = newSubServer(Options.SubHttpAddr, Options.SubHttpsAddr,
Options.MaxClients, this)
switch Options.Store {
case "kafka":
store.DefaultSubStore = storekfk.NewSubStore(this.subServer.closedConnCh, Options.Debug)
case "dummy":
store.DefaultSubStore = storedummy.NewSubStore(this.subServer.closedConnCh, Options.Debug)
default:
panic("invalid store")
}
}
return this
}