package main import ( "fmt" "os" "github.com/micro/cli" "github.com/micro/go-micro" "github.com/micro/go-micro/client" proto "github.com/micro/go-micro/examples/service/proto" "github.com/micro/go-micro/metadata" "github.com/micro/go-micro/server" "golang.org/x/net/context" ) /* Example usage of top level service initialisation including wrappers */ type logWrapper struct { client.Client } func (l *logWrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error { md, _ := metadata.FromContext(ctx) fmt.Printf("[Log Wrapper] ctx: %v service: %s method: %s\n", md, req.Service(), req.Method()) return l.Client.Call(ctx, req, rsp) } // Implements client.Wrapper as logWrapper func logWrap(c client.Client) client.Client { return &logWrapper{c} } // Implements the server.HandlerWrapper func logHandlerWrapper(fn server.HandlerFunc) server.HandlerFunc { return func(ctx context.Context, req server.Request, rsp interface{}) error { fmt.Printf("[Log Wrapper] Before serving request method: %v\n", req.Method()) err := fn(ctx, req, rsp) fmt.Println("[Log Wrapper] After serving request") return err } } type Greeter struct{} func (g *Greeter) Hello(ctx context.Context, req *proto.HelloRequest, rsp *proto.HelloResponse) error { rsp.Greeting = "Hello " + req.Name return nil } // Setup and the client func runClient(service micro.Service) { // Create new greeter client greeter := proto.NewGreeterClient("greeter", service.Client()) // Call the greeter rsp, err := greeter.Hello(context.TODO(), &proto.HelloRequest{Name: "John"}) if err != nil { fmt.Println(err) return } // Print response fmt.Println(rsp.Greeting) } 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 --run_client to run the client // Add runtime flags // We could do this below too micro.Flags(cli.BoolFlag{ Name: "run_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("run_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) } }