// 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)
}
}