func srv(ctx *cli.Context) {
service := micro.NewService(
micro.Name("go.micro.srv.db"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
if len(ctx.String("database_service_namespace")) > 0 {
db.DBServiceNamespace = ctx.String("database_service_namespace")
}
proto.RegisterDBHandler(service.Server(), new(handler.DB))
if err := db.Init(service.Client().Options().Selector); err != nil {
log.Fatal(err)
}
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
func srv(ctx *cli.Context) {
service := micro.NewService(
micro.Name("go.micro.srv.discovery"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
micro.BeforeStart(discovery.Start),
micro.AfterStop(discovery.Stop),
)
service.Server().Subscribe(
service.Server().NewSubscriber(
discovery.HeartbeatTopic,
discovery.Default.ProcessHeartbeat,
),
)
service.Server().Subscribe(
service.Server().NewSubscriber(
discovery.WatchTopic,
discovery.Default.ProcessResult,
),
)
proto.RegisterDiscoveryHandler(service.Server(), new(handler.Discovery))
proto2.RegisterRegistryHandler(service.Server(), new(handler.Registry))
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
func srv(ctx *cli.Context) {
service := micro.NewService(
micro.Name("go.micro.srv.auth"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
if len(ctx.GlobalString("database_url")) > 0 {
mysql.Url = ctx.GlobalString("database_url")
}
// register account handler
account.RegisterAccountHandler(service.Server(), new(handler.Account))
// register oauth2 handler
oauth2.RegisterOauth2Handler(service.Server(), new(handler.Oauth2))
// initialise database
if err := db.Init(); err != nil {
log.Fatal(err)
}
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
func srv(ctx *cli.Context) {
service := micro.NewService(
micro.Name("go.micro.srv.config"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
if len(ctx.GlobalString("database_url")) > 0 {
mysql.Url = ctx.GlobalString("database_url")
}
proto.RegisterConfigHandler(service.Server(), new(handler.Config))
// subcriber to watches
service.Server().Subscribe(service.Server().NewSubscriber(config.WatchTopic, config.Watcher))
if err := config.Init(); err != nil {
log.Fatal(err)
}
if err := db.Init(); err != nil {
log.Fatal(err)
}
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
func WebOpts(ctx *cli.Context) []web.Option {
var opts []web.Option
if ttl := ctx.GlobalInt("register_ttl"); ttl > 0 {
opts = append(opts, web.RegisterTTL(time.Duration(ttl)*time.Second))
}
if interval := ctx.GlobalInt("register_interval"); interval > 0 {
opts = append(opts, web.RegisterInterval(time.Duration(interval)*time.Second))
}
if name := ctx.GlobalString("server_name"); len(name) > 0 {
opts = append(opts, web.Name(name))
}
if ver := ctx.GlobalString("server_version"); len(ver) > 0 {
opts = append(opts, web.Version(ver))
}
if id := ctx.GlobalString("server_id"); len(id) > 0 {
opts = append(opts, web.Id(id))
}
if addr := ctx.GlobalString("server_address"); len(addr) > 0 {
opts = append(opts, web.Address(addr))
}
if adv := ctx.GlobalString("server_advertise"); len(adv) > 0 {
opts = append(opts, web.Advertise(adv))
}
return opts
}
func srv(ctx *cli.Context) {
service := micro.NewService(
micro.Name("go.micro.srv.trace"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
if len(ctx.GlobalString("database_url")) > 0 {
mysql.Url = ctx.GlobalString("database_url")
}
proto.RegisterTraceHandler(service.Server(), new(handler.Trace))
service.Server().Subscribe(
service.Server().NewSubscriber(trace.TraceTopic, trace.ProcessSpan),
)
if err := db.Init(); err != nil {
log.Fatal(err)
}
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
func srv(ctx *cli.Context) {
service := micro.NewService(
micro.Name("go.micro.srv.monitor"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
micro.BeforeStart(func() error {
monitor.DefaultMonitor.Run()
return nil
}),
)
// healthchecks
service.Server().Subscribe(
service.Server().NewSubscriber(
monitor.HealthCheckTopic,
monitor.DefaultMonitor.ProcessHealthCheck,
),
)
// status
service.Server().Subscribe(
service.Server().NewSubscriber(
monitor.StatusTopic,
monitor.DefaultMonitor.ProcessStatus,
),
)
// stats
service.Server().Subscribe(
service.Server().NewSubscriber(
monitor.StatsTopic,
monitor.DefaultMonitor.ProcessStats,
),
)
proto.RegisterMonitorHandler(service.Server(), new(handler.Monitor))
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
func srv(ctx *cli.Context) {
service := micro.NewService(
micro.Name("go.micro.srv.event"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
if len(ctx.GlobalString("database_url")) > 0 {
mysql.Url = ctx.GlobalString("database_url")
}
proto.RegisterEventHandler(service.Server(), new(handler.Event))
service.Server().Subscribe(
service.Server().NewSubscriber(
"micro.event.record",
event.Process,
server.SubscriberQueue("event-srv"),
),
)
// For watchers
service.Server().Subscribe(
service.Server().NewSubscriber(
"micro.event.record",
event.Stream,
),
)
if err := db.Init(); err != nil {
log.Fatal(err)
}
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
func srv(ctx *cli.Context) {
service := micro.NewService(
micro.Name("go.micro.srv.kv"),
micro.Version("latest"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
micro.Flags(),
)
opts := []kv.Option{
kv.Client(service.Client()),
kv.Server(service.Server()),
}
if len(ctx.String("namespace")) > 0 {
opts = append(opts, kv.Namespace(ctx.String("namespace")))
}
keyval := kv.NewKV(opts...)
defer keyval.Close()
service.Server().Init(server.WrapHandler(func(fn server.HandlerFunc) server.HandlerFunc {
return func(ctx context.Context, req server.Request, rsp interface{}) error {
ctx = kv.NewContext(ctx, keyval)
return fn(ctx, req, rsp)
}
}))
proto.RegisterStoreHandler(service.Server(), new(handler.Store))
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
func srv(ctx *cli.Context) {
service := micro.NewService(
micro.Name("go.micro.srv.router"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
if len(ctx.GlobalString("database_url")) > 0 {
mysql.Url = ctx.GlobalString("database_url")
}
router.Init(service)
proto.RegisterRouterHandler(service.Server(), new(handler.Router))
label.RegisterLabelHandler(service.Server(), new(handler.Label))
rule.RegisterRuleHandler(service.Server(), new(handler.Rule))
// subcriber to stats
service.Server().Subscribe(
service.Server().NewSubscriber(
router.StatsTopic,
router.ProcessStats,
),
)
// initialise database
if err := db.Init(); err != nil {
log.Fatal(err)
}
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
func run(ctx *cli.Context) {
// Parse flags
if len(ctx.String("inputs")) == 0 {
log.Println("[bot] no inputs specified")
os.Exit(1)
}
inputs := strings.Split(ctx.String("inputs"), ",")
if len(inputs) == 0 {
log.Println("[bot] no inputs specified")
os.Exit(1)
}
ios := make(map[string]input.Input)
cmds := make(map[string]command.Command)
// create built in commands
for pattern, cmd := range commands {
cmds[pattern] = cmd(ctx)
}
// take other commands
for pattern, cmd := range command.Commands {
if c, ok := cmds[pattern]; ok {
log.Printf("[bot] command %s already registered for pattern %s\n", c.String(), pattern)
continue
}
// register command
cmds[pattern] = cmd
}
// Parse inputs
for _, io := range inputs {
i, ok := input.Inputs[io]
if !ok {
log.Printf("[bot] input %s not found\n", i)
os.Exit(1)
}
ios[io] = i
}
// Start bot
b := newBot(ctx, ios, cmds)
if err := b.start(); err != nil {
log.Println("error starting bot", err)
os.Exit(1)
}
// setup service
service := micro.NewService(
micro.Name("go.micro.bot"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
// Run server
if err := service.Run(); err != nil {
log.Fatal(err)
}
// Stop bot
if err := b.stop(); err != nil {
log.Println("error stopping bot", err)
}
}
func run(ctx *cli.Context) {
// Init plugins
for _, p := range Plugins() {
p.Init(ctx)
}
var h http.Handler
r := mux.NewRouter()
s := &srv{r}
h = s
if ctx.GlobalBool("enable_stats") {
statsURL = "/stats"
st := stats.New()
s.HandleFunc("/stats", st.StatsHandler)
h = st.ServeHTTP(s)
st.Start()
defer st.Stop()
}
s.HandleFunc("/registry", registryHandler)
s.HandleFunc("/rpc", handler.RPC)
s.HandleFunc("/cli", cliHandler)
s.HandleFunc("/query", queryHandler)
s.HandleFunc("/favicon.ico", faviconHandler)
s.PathPrefix("/{service:[a-zA-Z0-9]+}").Handler(s.proxy())
s.HandleFunc("/", indexHandler)
var opts []server.Option
if ctx.GlobalBool("enable_tls") {
config, err := helper.TLSConfig(ctx)
if err != nil {
fmt.Println(err.Error())
return
}
opts = append(opts, server.EnableTLS(true))
opts = append(opts, server.TLSConfig(config))
}
// reverse wrap handler
plugins := Plugins()
for i := len(plugins); i > 0; i-- {
h = plugins[i-1].Handler()(h)
}
srv := server.NewServer(Address)
srv.Init(opts...)
srv.Handle("/", h)
// Initialise Server
service := micro.NewService(
micro.Name("go.micro.web"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
if err := srv.Start(); err != nil {
log.Fatal(err)
}
// Run server
if err := service.Run(); err != nil {
log.Fatal(err)
}
if err := srv.Stop(); err != nil {
log.Fatal(err)
}
}
func run(ctx *cli.Context, car *Sidecar) {
var opts []server.Option
if ctx.GlobalBool("enable_tls") {
cert := ctx.GlobalString("tls_cert_file")
key := ctx.GlobalString("tls_key_file")
if len(cert) > 0 && len(key) > 0 {
certs, err := tls.LoadX509KeyPair(cert, key)
if err != nil {
fmt.Println(err.Error())
return
}
config := &tls.Config{
Certificates: []tls.Certificate{certs},
}
opts = append(opts, server.EnableTLS(true))
opts = append(opts, server.TLSConfig(config))
} else {
fmt.Println("Enable TLS specified without certificate and key files")
return
}
}
r := http.NewServeMux()
// new server
srv := server.NewServer(Address)
srv.Init(opts...)
// register handlers
if car != nil {
log.Printf("Registering Health handler at %s", HealthPath)
r.Handle(HealthPath, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if c, err := car.hc(); err != nil {
http.Error(w, err.Error(), c)
return
}
}))
}
log.Printf("Registering Registry handler at %s", RegistryPath)
r.Handle(RegistryPath, http.HandlerFunc(handler.Registry))
log.Printf("Registering RPC handler at %s", RPCPath)
r.Handle(RPCPath, http.HandlerFunc(handler.RPC))
log.Printf("Registering Broker handler at %s", BrokerPath)
r.Handle(BrokerPath, http.HandlerFunc(handler.Broker))
var h http.Handler = r
if ctx.GlobalBool("enable_stats") {
st := stats.New()
r.Handle("/stats", http.HandlerFunc(st.StatsHandler))
h = st.ServeHTTP(r)
st.Start()
defer st.Stop()
}
srv.Handle("/", h)
// Initialise Server
service := micro.NewService(
micro.Name("go.micro.sidecar"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
if err := srv.Start(); err != nil {
log.Fatal(err)
}
// Run server
if err := service.Run(); err != nil {
log.Fatal(err)
}
if err := srv.Stop(); err != nil {
log.Fatal(err)
}
}
func run(ctx *cli.Context, car *sidecar) {
if len(ctx.String("address")) > 0 {
Address = ctx.String("address")
}
if len(ctx.String("cors")) > 0 {
origins := make(map[string]bool)
for _, origin := range strings.Split(ctx.String("cors"), ",") {
origins[origin] = true
}
CORS = origins
}
if len(ctx.String("namespace")) > 0 {
Namespace = ctx.String("namespace")
}
// Init plugins
for _, p := range Plugins() {
p.Init(ctx)
}
var opts []server.Option
if ctx.GlobalBool("enable_tls") {
config, err := helper.TLSConfig(ctx)
if err != nil {
fmt.Println(err.Error())
return
}
opts = append(opts, server.EnableTLS(true))
opts = append(opts, server.TLSConfig(config))
}
r := mux.NewRouter()
s := &srv{r}
// new server
srv := server.NewServer(Address)
srv.Init(opts...)
// register handlers
if car != nil {
log.Printf("Registering Health handler at %s", HealthPath)
r.Handle(HealthPath, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if c, err := car.hc(); err != nil {
http.Error(w, err.Error(), c)
return
}
}))
}
log.Printf("Registering Registry handler at %s", RegistryPath)
r.Handle(RegistryPath, http.HandlerFunc(handler.Registry))
log.Printf("Registering RPC handler at %s", RPCPath)
r.Handle(RPCPath, http.HandlerFunc(handler.RPC))
log.Printf("Registering Broker handler at %s", BrokerPath)
r.Handle(BrokerPath, http.HandlerFunc(handler.Broker))
log.Printf("Registering Root Handler at %s", RootPath)
r.PathPrefix(RootPath).Handler(handler.RPCX(Namespace))
var h http.Handler = s
if ctx.GlobalBool("enable_stats") {
st := stats.New()
r.Handle("/stats", http.HandlerFunc(st.StatsHandler))
h = st.ServeHTTP(r)
st.Start()
defer st.Stop()
}
// reverse wrap handler
plugins := append(Plugins(), plugin.Plugins()...)
for i := len(plugins); i > 0; i-- {
h = plugins[i-1].Handler()(h)
}
srv.Handle("/", h)
// Initialise Server
service := micro.NewService(
micro.Name("go.micro.sidecar"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
if err := srv.Start(); err != nil {
log.Fatal(err)
}
// Run server
if err := service.Run(); err != nil {
log.Fatal(err)
}
if err := srv.Stop(); err != nil {
log.Fatal(err)
}
}
func run(ctx *cli.Context) {
// Init API
var opts []server.Option
if ctx.GlobalBool("enable_tls") {
cert := ctx.GlobalString("tls_cert_file")
key := ctx.GlobalString("tls_key_file")
if len(cert) > 0 && len(key) > 0 {
certs, err := tls.LoadX509KeyPair(cert, key)
if err != nil {
fmt.Println(err.Error())
return
}
config := &tls.Config{
Certificates: []tls.Certificate{certs},
}
opts = append(opts, server.EnableTLS(true))
opts = append(opts, server.TLSConfig(config))
} else {
fmt.Println("Enable TLS specified without certificate and key files")
return
}
}
// create the router
r := mux.NewRouter()
s := &srv{r}
var h http.Handler = s
if ctx.GlobalBool("enable_stats") {
st := stats.New()
r.HandleFunc("/stats", st.StatsHandler)
h = st.ServeHTTP(s)
st.Start()
defer st.Stop()
}
log.Printf("Registering RPC Handler at %s", RPCPath)
r.HandleFunc(RPCPath, handler.RPC)
switch ctx.GlobalString("api_handler") {
case "proxy":
log.Printf("Registering API Proxy Handler at %s", ProxyPath)
r.PathPrefix(ProxyPath).Handler(handler.Proxy(Namespace, false))
default:
log.Printf("Registering API Handler at %s", APIPath)
r.PathPrefix(APIPath).HandlerFunc(apiHandler)
}
// create the server
api := server.NewServer(Address)
api.Init(opts...)
api.Handle("/", h)
// Initialise Server
service := micro.NewService(
micro.Name("go.micro.api"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
// Start API
if err := api.Start(); err != nil {
log.Fatal(err)
}
// Run server
if err := service.Run(); err != nil {
log.Fatal(err)
}
// Stop API
if err := api.Stop(); err != nil {
log.Fatal(err)
}
}
func run(ctx *cli.Context) {
// Init API
var opts []server.Option
if ctx.GlobalBool("enable_tls") {
cert := ctx.GlobalString("tls_cert_file")
key := ctx.GlobalString("tls_key_file")
if len(cert) > 0 && len(key) > 0 {
certs, err := tls.LoadX509KeyPair(cert, key)
if err != nil {
fmt.Println(err.Error())
return
}
config := &tls.Config{
Certificates: []tls.Certificate{certs},
}
opts = append(opts, server.EnableTLS(true))
opts = append(opts, server.TLSConfig(config))
} else {
fmt.Println("Enable TLS specified without certificate and key files")
return
}
}
// create the router
r := http.NewServeMux()
log.Infof("Registering RPC Handler at %s", RPCPath)
r.HandleFunc(RPCPath, handler.RPC)
log.Infof("Registering API Handler at %s", APIPath)
r.HandleFunc(APIPath, restHandler)
// create the server
api := server.NewServer(Address)
api.Init(opts...)
api.Handle("/", &srv{r})
// Initialise Server
service := micro.NewService(
micro.Name("go.micro.api"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
// Start API
if err := api.Start(); err != nil {
log.Fatal(err)
}
// Run server
if err := service.Run(); err != nil {
log.Fatal(err)
}
// Stop API
if err := api.Stop(); err != nil {
log.Fatal(err)
}
}
func run(ctx *cli.Context) {
r := mux.NewRouter()
s := &srv{r}
s.HandleFunc("/registry", registryHandler)
s.HandleFunc("/rpc", handler.RPC)
s.HandleFunc("/query", queryHandler)
s.HandleFunc("/favicon.ico", faviconHandler)
s.PathPrefix("/{service:[a-zA-Z0-9]+}").Handler(s.proxy())
s.HandleFunc("/", indexHandler)
var opts []server.Option
if ctx.GlobalBool("enable_tls") {
cert := ctx.GlobalString("tls_cert_file")
key := ctx.GlobalString("tls_key_file")
if len(cert) > 0 && len(key) > 0 {
certs, err := tls.LoadX509KeyPair(cert, key)
if err != nil {
fmt.Println(err.Error())
return
}
config := &tls.Config{
Certificates: []tls.Certificate{certs},
}
opts = append(opts, server.EnableTLS(true))
opts = append(opts, server.TLSConfig(config))
} else {
fmt.Println("Enable TLS specified without certificate and key files")
return
}
}
srv := server.NewServer(Address)
srv.Init(opts...)
srv.Handle("/", s)
// Initialise Server
service := micro.NewService(
micro.Name("go.micro.web"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
if err := srv.Start(); err != nil {
log.Fatal(err)
}
// Run server
if err := service.Run(); err != nil {
log.Fatal(err)
}
if err := srv.Stop(); err != nil {
log.Fatal(err)
}
}
func run(ctx *cli.Context) {
if len(ctx.String("address")) > 0 {
Address = ctx.String("address")
}
if len(ctx.String("handler")) > 0 {
Handler = ctx.String("handler")
}
if len(ctx.String("namespace")) > 0 {
Namespace = ctx.String("namespace")
}
if len(ctx.String("cors")) > 0 {
origins := make(map[string]bool)
for _, origin := range strings.Split(ctx.String("cors"), ",") {
origins[origin] = true
}
CORS = origins
}
// Init plugins
for _, p := range Plugins() {
p.Init(ctx)
}
// Init API
var opts []server.Option
if ctx.GlobalBool("enable_tls") {
config, err := helper.TLSConfig(ctx)
if err != nil {
fmt.Println(err.Error())
return
}
opts = append(opts, server.EnableTLS(true))
opts = append(opts, server.TLSConfig(config))
}
// create the router
r := mux.NewRouter()
s := &srv{r}
var h http.Handler = s
if ctx.GlobalBool("enable_stats") {
st := stats.New()
r.HandleFunc("/stats", st.StatsHandler)
h = st.ServeHTTP(s)
st.Start()
defer st.Stop()
}
log.Printf("Registering RPC Handler at %s", RPCPath)
r.HandleFunc(RPCPath, handler.RPC)
switch Handler {
case "rpc":
log.Printf("Registering API RPC Handler at %s", APIPath)
r.PathPrefix(APIPath).Handler(handler.RPCX(Namespace))
case "proxy":
log.Printf("Registering API Proxy Handler at %s", ProxyPath)
r.PathPrefix(ProxyPath).Handler(handler.Proxy(Namespace, false))
default:
log.Printf("Registering API Default Handler at %s", APIPath)
r.PathPrefix(APIPath).Handler(handler.API(Namespace))
}
// reverse wrap handler
plugins := append(Plugins(), plugin.Plugins()...)
for i := len(plugins); i > 0; i-- {
h = plugins[i-1].Handler()(h)
}
// create the server
api := server.NewServer(Address)
api.Init(opts...)
api.Handle("/", h)
// Initialise Server
service := micro.NewService(
micro.Name("go.micro.api"),
micro.RegisterTTL(
time.Duration(ctx.GlobalInt("register_ttl"))*time.Second,
),
micro.RegisterInterval(
time.Duration(ctx.GlobalInt("register_interval"))*time.Second,
),
)
// Start API
if err := api.Start(); err != nil {
log.Fatal(err)
}
// Run server
if err := service.Run(); err != nil {
log.Fatal(err)
}
// Stop API
if err := api.Stop(); err != nil {
log.Fatal(err)
}
}