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 DeregisterService(c *cli.Context, args []string) ([]byte, error) {
if len(args) == 0 {
return nil, errors.New("require service definition")
}
req := strings.Join(args, " ")
if p := c.GlobalString("proxy_address"); len(p) > 0 {
if err := del(p+"/registry", []byte(req), nil); err != nil {
return nil, err
}
return []byte("ok"), nil
}
var service *registry.Service
d := json.NewDecoder(strings.NewReader(req))
d.UseNumber()
if err := d.Decode(&service); err != nil {
return nil, err
}
if err := (*cmd.DefaultOptions().Registry).Deregister(service); err != nil {
return nil, err
}
return []byte("ok"), nil
}
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 ListServices(c *cli.Context) ([]byte, error) {
var rsp []*registry.Service
var err error
if p := c.GlobalString("proxy_address"); len(p) > 0 {
if err := get(p+"/registry", &rsp); err != nil {
return nil, err
}
} else {
rsp, err = (*cmd.DefaultOptions().Registry).ListServices()
if err != nil {
return nil, err
}
}
sort.Sort(sortedServices{rsp})
var services []string
for _, service := range rsp {
services = append(services, service.Name)
}
return []byte(strings.Join(services, "\n")), nil
}
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 web(ctx *cli.Context) {
opts := []gweb.Option{
gweb.Name("go.micro.web.discovery"),
gweb.Handler(whandler.Router()),
}
opts = append(opts, helper.WebOpts(ctx)...)
templateDir := "discovery/templates"
if dir := ctx.GlobalString("html_dir"); len(dir) > 0 {
templateDir = dir
}
whandler.Init(
templateDir,
proto.NewDiscoveryClient("go.micro.srv.discovery", *cmd.DefaultOptions().Client),
proto2.NewRegistryClient("go.micro.srv.discovery", *cmd.DefaultOptions().Client),
)
service := gweb.NewService(opts...)
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
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 QueryService(c *cli.Context, args []string) ([]byte, error) {
if len(args) < 2 {
return nil, errors.New("require service and method")
}
var req, service, method string
service = args[0]
method = args[1]
if len(args) > 2 {
req = strings.Join(args[2:], " ")
}
// empty request
if len(req) == 0 {
req = `{}`
}
var request map[string]interface{}
var response json.RawMessage
if p := c.GlobalString("proxy_address"); len(p) > 0 {
request = map[string]interface{}{
"service": service,
"method": method,
"request": req,
}
b, err := json.Marshal(request)
if err != nil {
return nil, err
}
if err := post(p+"/rpc", b, &response); err != nil {
return nil, err
}
} else {
d := json.NewDecoder(strings.NewReader(req))
d.UseNumber()
if err := d.Decode(&request); err != nil {
return nil, err
}
creq := (*cmd.DefaultOptions().Client).NewJsonRequest(service, method, request)
err := (*cmd.DefaultOptions().Client).Call(context.Background(), creq, &response)
if err != nil {
return nil, fmt.Errorf("error calling %s.%s: %v\n", service, method, err)
}
}
var out bytes.Buffer
defer out.Reset()
if err := json.Indent(&out, response, "", "\t"); err != nil {
return nil, err
}
return out.Bytes(), nil
}
func queryService(c *cli.Context) {
if len(c.Args()) < 2 {
fmt.Println("require service and method")
return
}
service := c.Args()[0]
method := c.Args()[1]
var request map[string]interface{}
var response map[string]interface{}
if p := c.GlobalString("proxy_address"); len(p) > 0 {
request = map[string]interface{}{
"service": service,
"method": method,
"request": []byte(strings.Join(c.Args()[2:], " ")),
}
b, err := json.Marshal(request)
if err != nil {
fmt.Println(err.Error())
return
}
if err := post(p+"/rpc", b, &response); err != nil {
fmt.Println(err.Error())
return
}
} else {
json.Unmarshal([]byte(strings.Join(c.Args()[2:], " ")), &request)
req := (*cmd.DefaultOptions().Client).NewJsonRequest(service, method, request)
err := (*cmd.DefaultOptions().Client).Call(context.Background(), req, &response)
if err != nil {
fmt.Printf("error calling %s.%s: %v\n", service, method, err)
return
}
}
b, _ := json.MarshalIndent(response, "", "\t")
fmt.Println(string(b))
}
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 TLSConfig(ctx *cli.Context) (*tls.Config, error) {
cert := ctx.GlobalString("tls_cert_file")
key := ctx.GlobalString("tls_key_file")
ca := ctx.GlobalString("tls_client_ca_file")
if len(cert) > 0 && len(key) > 0 {
certs, err := tls.LoadX509KeyPair(cert, key)
if err != nil {
return nil, err
}
if len(ca) > 0 {
caCert, err := ioutil.ReadFile(ca)
if err != nil {
return nil, err
}
caCertPool := x509.NewCertPool()
caCertPool.AppendCertsFromPEM(caCert)
return &tls.Config{
Certificates: []tls.Certificate{certs},
ClientCAs: caCertPool,
ClientAuth: tls.RequireAndVerifyClientCert,
}, nil
}
return &tls.Config{
Certificates: []tls.Certificate{certs},
}, nil
}
return nil, errors.New("TLS certificate and key files not specified")
}
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 deregisterService(c *cli.Context) {
if len(c.Args()) != 1 {
fmt.Println("require service definition")
return
}
if p := c.GlobalString("proxy_address"); len(p) > 0 {
if err := del(p+"/registry", []byte(c.Args().First()), nil); err != nil {
fmt.Println(err.Error())
}
return
}
var service *registry.Service
if err := json.Unmarshal([]byte(c.Args().First()), &service); err != nil {
fmt.Println(err.Error())
return
}
if err := (*cmd.DefaultOptions().Registry).Deregister(service); err != nil {
fmt.Println(err.Error())
return
}
}
func listServices(c *cli.Context) {
var rsp []*registry.Service
var err error
if p := c.GlobalString("proxy_address"); len(p) > 0 {
if err := get(p+"/registry", &rsp); err != nil {
fmt.Println(err.Error())
return
}
} else {
rsp, err = (*cmd.DefaultOptions().Registry).ListServices()
if err != nil {
fmt.Println(err.Error())
return
}
}
ss := sortedServices{rsp}
sort.Sort(ss)
for _, service := range ss.services {
fmt.Println(service.Name)
}
}
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 QueryHealth(c *cli.Context, args []string) ([]byte, error) {
if len(args) == 0 {
return nil, errors.New("require service name")
}
service, err := (*cmd.DefaultOptions().Registry).GetService(args[0])
if err != nil {
return nil, err
}
if service == nil || len(service) == 0 {
return nil, errors.New("Service not found")
}
req := (*cmd.DefaultOptions().Client).NewRequest(service[0].Name, "Debug.Health", &proto.HealthRequest{})
var output []string
// print things
output = append(output, "service "+service[0].Name)
for _, serv := range service {
// print things
output = append(output, "\nversion "+serv.Version)
output = append(output, "\nnode\t\taddress:port\t\tstatus")
// query health for every node
for _, node := range serv.Nodes {
address := node.Address
if node.Port > 0 {
address = fmt.Sprintf("%s:%d", address, node.Port)
}
rsp := &proto.HealthResponse{}
var err error
if p := c.GlobalString("proxy_address"); len(p) > 0 {
// call using proxy
request := map[string]interface{}{
"service": service[0].Name,
"method": "Debug.Health",
"address": address,
}
b, err := json.Marshal(request)
if err != nil {
return nil, err
}
if err := post(p+"/rpc", b, &rsp); err != nil {
return nil, err
}
} else {
// call using client
err = (*cmd.DefaultOptions().Client).CallRemote(context.Background(), address, req, rsp)
}
var status string
if err != nil {
status = err.Error()
} else {
status = rsp.Status
}
output = append(output, fmt.Sprintf("%s\t\t%s:%d\t\t%s", node.Id, node.Address, node.Port, status))
}
}
return []byte(strings.Join(output, "\n")), nil
}
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 GetService(c *cli.Context, args []string) ([]byte, error) {
if len(args) == 0 {
return nil, errors.New("service requested")
}
var output []string
var service []*registry.Service
var err error
if p := c.GlobalString("proxy_address"); len(p) > 0 {
if err := get(p+"/registry?service="+args[0], &service); err != nil {
return nil, err
}
} else {
service, err = (*cmd.DefaultOptions().Registry).GetService(args[0])
}
if err != nil {
return nil, err
}
if len(service) == 0 {
return nil, errors.New("Service not found")
}
output = append(output, "service "+service[0].Name)
for _, serv := range service {
output = append(output, "\nversion "+serv.Version)
output = append(output, "\nId\tAddress\tPort\tMetadata")
for _, node := range serv.Nodes {
var meta []string
for k, v := range node.Metadata {
meta = append(meta, k+"="+v)
}
output = append(output, fmt.Sprintf("%s\t%s\t%d\t%s", node.Id, node.Address, node.Port, strings.Join(meta, ",")))
}
}
for _, e := range service[0].Endpoints {
var request, response string
var meta []string
for k, v := range e.Metadata {
meta = append(meta, k+"="+v)
}
if e.Request != nil && len(e.Request.Values) > 0 {
request = "{\n"
for _, v := range e.Request.Values {
request += formatEndpoint(v, 0)
}
request += "}"
} else {
request = "{}"
}
if e.Response != nil && len(e.Response.Values) > 0 {
response = "{\n"
for _, v := range e.Response.Values {
response += formatEndpoint(v, 0)
}
response += "}"
} else {
response = "{}"
}
output = append(output, fmt.Sprintf("\nEndpoint: %s\nMetadata: %s\n", e.Name, strings.Join(meta, ",")))
output = append(output, fmt.Sprintf("Request: %s\n\nResponse: %s\n", request, response))
}
return []byte(strings.Join(output, "\n")), nil
}
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 QueryStats(c *cli.Context, args []string) ([]byte, error) {
if len(args) == 0 {
return nil, errors.New("require service name")
}
service, err := (*cmd.DefaultOptions().Registry).GetService(args[0])
if err != nil {
return nil, err
}
if service == nil || len(service) == 0 {
return nil, errors.New("Service not found")
}
req := (*cmd.DefaultOptions().Client).NewRequest(service[0].Name, "Debug.Stats", &proto.StatsRequest{})
var output []string
// print things
output = append(output, "service "+service[0].Name)
for _, serv := range service {
// print things
output = append(output, "\nversion "+serv.Version)
output = append(output, "\nnode\t\taddress:port\t\tstarted\tuptime\tmemory\tthreads\tgc")
// query health for every node
for _, node := range serv.Nodes {
address := node.Address
if node.Port > 0 {
address = fmt.Sprintf("%s:%d", address, node.Port)
}
rsp := &proto.StatsResponse{}
var err error
if p := c.GlobalString("proxy_address"); len(p) > 0 {
// call using proxy
request := map[string]interface{}{
"service": service[0].Name,
"method": "Debug.Stats",
"address": address,
}
b, err := json.Marshal(request)
if err != nil {
return nil, err
}
if err := post(p+"/rpc", b, &rsp); err != nil {
return nil, err
}
} else {
// call using client
err = (*cmd.DefaultOptions().Client).CallRemote(context.Background(), address, req, rsp)
}
var started, uptime, memory, gc string
if err == nil {
started = time.Unix(int64(rsp.Started), 0).Format("Jan 2 15:04:05")
uptime = fmt.Sprintf("%v", time.Duration(rsp.Uptime)*time.Second)
memory = fmt.Sprintf("%.2fmb", float64(rsp.Memory)/(1024.0*1024.0))
gc = fmt.Sprintf("%v", time.Duration(rsp.Gc))
}
line := fmt.Sprintf("%s\t\t%s:%d\t\t%s\t%s\t%s\t%d\t%s",
node.Id, node.Address, node.Port, started, uptime, memory, rsp.Threads, gc)
output = append(output, line)
}
}
return []byte(strings.Join(output, "\n")), nil
}
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 queryHealth(c *cli.Context) {
if !c.Args().Present() {
fmt.Println("require service name")
return
}
service, err := (*cmd.DefaultOptions().Registry).GetService(c.Args().First())
if err != nil {
fmt.Println(err.Error())
return
}
if service == nil || len(service) == 0 {
fmt.Println("Service not found")
return
}
req := (*cmd.DefaultOptions().Client).NewRequest(service[0].Name, "Debug.Health", &proto.HealthRequest{})
// print things
fmt.Printf("service %s\n\n", service[0].Name)
for _, serv := range service {
// print things
fmt.Println("\nversion ", serv.Version)
fmt.Println("\nnode\t\taddress:port\t\tstatus")
// query health for every node
for _, node := range serv.Nodes {
address := node.Address
if node.Port > 0 {
address = fmt.Sprintf("%s:%d", address, node.Port)
}
rsp := &proto.HealthResponse{}
var err error
if p := c.GlobalString("proxy_address"); len(p) > 0 {
// call using proxy
request := map[string]interface{}{
"service": service[0].Name,
"method": "Debug.Health",
"address": address,
}
b, err := json.Marshal(request)
if err != nil {
fmt.Println(err.Error())
return
}
if err := post(p+"/rpc", b, &rsp); err != nil {
fmt.Println(err.Error())
return
}
} else {
// call using client
err = (*cmd.DefaultOptions().Client).CallRemote(context.Background(), address, req, rsp)
}
var status string
if err != nil {
status = err.Error()
} else {
status = rsp.Status
}
fmt.Printf("%s\t\t%s:%d\t\t%s\n", node.Id, node.Address, node.Port, status)
}
}
}
func getService(c *cli.Context) {
if !c.Args().Present() {
fmt.Println("Service required")
return
}
var service []*registry.Service
var err error
if p := c.GlobalString("proxy_address"); len(p) > 0 {
if err := get(p+"/registry?service="+c.Args().First(), &service); err != nil {
fmt.Println(err.Error())
return
}
} else {
service, err = (*cmd.DefaultOptions().Registry).GetService(c.Args().First())
}
if err != nil {
fmt.Println(err.Error())
return
}
if len(service) == 0 {
fmt.Println("Service not found")
return
}
fmt.Printf("service %s\n", service[0].Name)
for _, serv := range service {
fmt.Println("\nversion ", serv.Version)
fmt.Println("\nId\tAddress\tPort\tMetadata")
for _, node := range serv.Nodes {
var meta []string
for k, v := range node.Metadata {
meta = append(meta, k+"="+v)
}
fmt.Printf("%s\t%s\t%d\t%s\n", node.Id, node.Address, node.Port, strings.Join(meta, ","))
}
}
for _, e := range service[0].Endpoints {
var request, response string
var meta []string
for k, v := range e.Metadata {
meta = append(meta, k+"="+v)
}
if e.Request != nil && len(e.Request.Values) > 0 {
request = "{\n"
for _, v := range e.Request.Values {
request += formatEndpoint(v, 0)
}
request += "}"
} else {
request = "{}"
}
if e.Response != nil && len(e.Response.Values) > 0 {
response = "{\n"
for _, v := range e.Response.Values {
response += formatEndpoint(v, 0)
}
response += "}"
} else {
response = "{}"
}
fmt.Printf("\nEndpoint: %s\nMetadata: %s\n", e.Name, strings.Join(meta, ","))
fmt.Printf("Request: %s\n\nResponse: %s\n", request, response)
}
}