// Register registers an web plugin func Register(pl plugin.Plugin) error { for _, p := range plugin.Plugins() { if p.String() == pl.String() { return fmt.Errorf("%s registered globally", pl.String()) } } return defaultManager.Register(pl) }
func setup(app *ccli.App) { app.Flags = append(app.Flags, ccli.BoolFlag{ Name: "enable_tls", Usage: "Enable TLS", EnvVar: "MICRO_ENABLE_TLS", }, ccli.StringFlag{ Name: "tls_cert_file", Usage: "TLS Certificate file", EnvVar: "MICRO_TLS_CERT_FILE", }, ccli.StringFlag{ Name: "tls_key_file", Usage: "TLS Key file", EnvVar: "MICRO_TLS_KEY_FILE", }, ccli.StringFlag{ Name: "tls_client_ca_file", Usage: "TLS CA file to verify clients against", EnvVar: "MICRO_TLS_CLIENT_CA_FILE", }, ccli.StringFlag{ Name: "api_address", Usage: "Set the api address e.g 0.0.0.0:8080", EnvVar: "MICRO_API_ADDRESS", }, ccli.StringFlag{ Name: "proxy_address", Usage: "Proxy requests via the HTTP address specified", EnvVar: "MICRO_PROXY_ADDRESS", }, ccli.StringFlag{ Name: "sidecar_address", Usage: "Set the sidecar address e.g 0.0.0.0:8081", EnvVar: "MICRO_SIDECAR_ADDRESS", }, ccli.StringFlag{ Name: "web_address", Usage: "Set the web UI address e.g 0.0.0.0:8082", EnvVar: "MICRO_WEB_ADDRESS", }, ccli.IntFlag{ Name: "register_ttl", EnvVar: "MICRO_REGISTER_TTL", Usage: "Register TTL in seconds", }, ccli.IntFlag{ Name: "register_interval", EnvVar: "MICRO_REGISTER_INTERVAL", Usage: "Register interval in seconds", }, ccli.StringFlag{ Name: "api_handler", Usage: "Specify the request handler to be used for mapping HTTP requests to services. e.g api, proxy", EnvVar: "MICRO_API_HANDLER", }, ccli.StringFlag{ Name: "api_namespace", Usage: "Set the namespace used by the API e.g. com.example.api", EnvVar: "MICRO_API_NAMESPACE", }, ccli.StringFlag{ Name: "web_namespace", Usage: "Set the namespace used by the Web proxy e.g. com.example.web", EnvVar: "MICRO_WEB_NAMESPACE", }, ccli.StringFlag{ Name: "api_cors", Usage: "Comma separated whitelist of allowed origins for CORS", EnvVar: "MICRO_API_CORS", }, ccli.StringFlag{ Name: "web_cors", Usage: "Comma separated whitelist of allowed origins for CORS", EnvVar: "MICRO_WEB_CORS", }, ccli.StringFlag{ Name: "sidecar_cors", Usage: "Comma separated whitelist of allowed origins for CORS", EnvVar: "MICRO_SIDECAR_CORS", }, ccli.BoolFlag{ Name: "enable_stats", Usage: "Enable stats", EnvVar: "MICRO_ENABLE_STATS", }, ) plugins := plugin.Plugins() for _, p := range plugins { if flags := p.Flags(); len(flags) > 0 { app.Flags = append(app.Flags, flags...) } if cmds := p.Commands(); len(cmds) > 0 { app.Commands = append(app.Commands, cmds...) } } before := app.Before app.Before = func(ctx *ccli.Context) error { if len(ctx.String("api_address")) > 0 { api.Address = ctx.String("api_address") } if len(ctx.String("sidecar_address")) > 0 { car.Address = ctx.String("sidecar_address") } if len(ctx.String("web_address")) > 0 { web.Address = ctx.String("web_address") } if len(ctx.String("api_namespace")) > 0 { api.Namespace = ctx.String("api_namespace") } if len(ctx.String("web_namespace")) > 0 { web.Namespace = ctx.String("web_namespace") } // origin comma separated string to map fn := func(s string) map[string]bool { origins := make(map[string]bool) for _, origin := range strings.Split(s, ",") { origins[origin] = true } return origins } if len(ctx.String("api_cors")) > 0 { api.CORS = fn(ctx.String("api_cors")) } if len(ctx.String("sidecar_cors")) > 0 { car.CORS = fn(ctx.String("sidecar_cors")) } if len(ctx.String("web_cors")) > 0 { web.CORS = fn(ctx.String("web_cors")) } for _, p := range plugins { p.Init(ctx) } return before(ctx) } }
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) { if len(ctx.String("address")) > 0 { Address = ctx.String("address") } 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) } 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 := append(Plugins(), plugin.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) { 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) } }