// WrapHandler adds a handler Wrapper to a list of options passed into the server
func WrapHandler(w ...server.HandlerWrapper) Option {
return func(o *Options) {
var wrappers []server.Option
for _, wrap := range w {
wrappers = append(wrappers, server.WrapHandler(wrap))
}
// Init once
o.Server.Init(wrappers...)
}
}
func main() {
// optionally setup command line usage
cmd.Init()
md := server.DefaultOptions().Metadata
md["datacenter"] = "local"
server.DefaultServer = server.NewServer(
server.WrapHandler(logWrapper),
server.WrapSubscriber(logSubWrapper),
server.Metadata(md),
)
// Initialise Server
server.Init(
server.Name("go.micro.srv.example"),
)
// Register Handlers
server.Handle(
server.NewHandler(
new(handler.Example),
),
)
// Register Subscribers
if err := server.Subscribe(
server.NewSubscriber(
"topic.go.micro.srv.example",
new(subscriber.Example),
),
); err != nil {
log.Fatal(err)
}
if err := server.Subscribe(
server.NewSubscriber(
"topic.go.micro.srv.example",
subscriber.Handler,
),
); err != nil {
log.Fatal(err)
}
// Run server
if err := server.Run(); err != nil {
log.Fatal(err)
}
}
func main() {
// Create a new service. Optionally include some options here.
service := micro.NewService(
micro.Client(client.NewClient(client.Wrap(logWrap))),
micro.Server(server.NewServer(server.WrapHandler(logHandlerWrapper))),
micro.Name("greeter"),
micro.Version("latest"),
micro.Metadata(map[string]string{
"type": "helloworld",
}),
// Setup some flags. Specify --client to run the client
// Add runtime flags
// We could do this below too
micro.Flags(cli.BoolFlag{
Name: "client",
Usage: "Launch the client",
}),
)
// Init will parse the command line flags. Any flags set will
// override the above settings. Options defined here will
// override anything set on the command line.
service.Init(
// Add runtime action
// We could actually do this above
micro.Action(func(c *cli.Context) {
if c.Bool("client") {
runClient(service)
os.Exit(0)
}
}),
)
// By default we'll run the server unless the flags catch us
// Setup the server
// Register handler
proto.RegisterGreeterHandler(service.Server(), new(Greeter))
// Run the server
if err := service.Run(); err != nil {
fmt.Println(err)
}
}
func main() {
// optionally setup command line usage
cmd.Init()
t := trace.NewTrace()
defer t.Close()
srv := ®istry.Service{
Name: "go.micro.srv.example",
}
client.DefaultClient = client.NewClient(
client.Wrap(
trace.ClientWrapper(t, srv),
),
)
server.DefaultServer = server.NewServer(
server.WrapHandler(trace.HandlerWrapper(t, srv)),
)
// Initialise Server
server.Init(
server.Name("go.micro.srv.example"),
)
// Register Handlers
server.Handle(
server.NewHandler(
new(handler.Example),
),
)
server.Handle(
server.NewHandler(
new(Ping),
),
)
// Run server
if err := server.Run(); err != nil {
log.Fatal(err)
}
}
func main() {
// optionally setup command line usage
cmd.Init()
t := trace.NewTrace()
if err := t.Start(); err != nil {
log.Fatal(err)
}
srv := ®istry.Service{
Name: "go.server",
}
server.DefaultServer = server.NewServer(
server.WrapHandler(trace.HandlerWrapper(t, srv)),
)
// Initialise Server
server.Init(
server.Name("go.micro.srv.example"),
)
// Register Handlers
server.Handle(
server.NewHandler(
new(handler.Example),
),
)
// Run server
if err := server.Run(); err != nil {
log.Fatal(err)
}
if err := t.Stop(); 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)
}
}