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 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 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 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 (r *router) Init(ctx *cli.Context) error { // TODO: Make this more configurable and add more sources var conf config.Config if c := ctx.String("config_source"); len(c) == 0 && r.opts.Config == nil { return errors.New("config source must be defined") } else if len(c) > 0 { var source config.Source switch c { case "platform": source = config.NewSource() case "file": fileName := DefaultFile parts := strings.Split(c, ":") if len(parts) > 1 { fileName = parts[1] } source = file.NewSource(config.SourceName(fileName)) default: return errors.New("Unknown config source " + c) } conf = config.NewConfig(config.WithSource(source)) } else { conf = r.opts.Config } go r.run(conf) return nil }
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 getService(c *cli.Context) { rsp, err := command.GetService(c, c.Args()) if err != nil { fmt.Println(err) return } fmt.Println(string(rsp)) }
func queryHealth(c *cli.Context) { rsp, err := command.QueryHealth(c, c.Args()) if err != nil { fmt.Println(err) return } fmt.Println(string(rsp)) }
func getService(c *cli.Context) { if !c.Args().Present() { fmt.Println("Service required") return } 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) } }
func (p *slackInput) Init(ctx *cli.Context) error { debug := ctx.Bool("slack_debug") token := ctx.String("slack_token") if len(token) == 0 { return errors.New("missing slack token") } p.debug = debug p.token = token return nil }
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.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) } }
// TODO: stream via HTTP func streamService(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{} json.Unmarshal([]byte(strings.Join(c.Args()[2:], " ")), &request) req := (*cmd.DefaultOptions().Client).NewJsonRequest(service, method, request) stream, err := (*cmd.DefaultOptions().Client).Stream(context.Background(), req) if err != nil { fmt.Printf("error calling %s.%s: %v\n", service, method, err) return } if err := stream.Send(request); err != nil { fmt.Printf("error sending to %s.%s: %v\n", service, method, err) return } for { var response map[string]interface{} if err := stream.Recv(&response); err != nil { fmt.Printf("error receiving from %s.%s: %v\n", service, method, err) return } b, _ := json.MarshalIndent(response, "", "\t") fmt.Println(string(b)) // artificial delay time.Sleep(time.Millisecond * 10) } }
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.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 deregisterService(c *cli.Context) { if len(c.Args()) != 1 { fmt.Println("require service definition") 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 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 runClient(service micro.Service, c *cli.Context) { // Create new greeter client greeter := greeterProto.NewGreeterClient("greeter", service.Client()) name := "World" if flagName := c.String("name"); flagName != "" { name = flagName } // Call the greeter rsp, err := greeter.Hello(context.TODO(), &greeterProto.HelloRequest{Name: name}) if err != nil { fmt.Println(err) return } // Print response fmt.Println(rsp.Greeting) }
func (h *hipchatInput) Init(ctx *cli.Context) error { username := ctx.String("hipchat_username") password := ctx.String("hipchat_password") server := ctx.String("hipchat_server") debug := ctx.Bool("hipchat_debug") if len(username) == 0 { return errors.New("require username") } if len(password) == 0 { return errors.New("require password") } if len(server) == 0 { return errors.New("require server") } h.username = username h.password = password h.server = server h.debug = debug return nil }
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 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 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{}) fmt.Printf("service %s\n\n", service[0].Name) for _, serv := range service { fmt.Println("\nversion ", serv.Version) fmt.Println("\nnode\t\taddress:port\t\tstatus") for _, node := range serv.Nodes { address := node.Address if node.Port > 0 { address = fmt.Sprintf("%s:%d", address, node.Port) } rsp := &proto.HealthResponse{} 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 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{} 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 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 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 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 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) { // 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) } }