go-micro wrapper as a service - go

Question

Question is about using go-micro wrapper as a separate service - if anyone knows how to use it properly please let me know. my example - authWrapper, so all api services should be able to use it, it should be discovered via standard service discovery, to make any changes to authWrapper only 1 service should be rebuild (I didn't find a way how to properly pass context.Context from api service to authWrapper via rpc call)
go-micro docs
go-micro wrapper examples
api's code where authWrapper gets called:
func main() {
service := micro.NewService(
micro.Name("go.micro.api.account"),
micro.WrapHandler(AuthWrapper),
)
fmt.Println("service created")
service.Init()
account.RegisterAccountHandler(service.Server(),
&handler.Account{
ProfileServiceClient: profile.NewProfileServiceClient("go.micro.srv.profile", service.Client()),
AuthServiceClient: auth.NewAuthServiceClient("go.micro.srv.auth", service.Client()),
})
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
and authWrapper:
var methodsWithoutAuth = map[string]bool{"Account.Auth": true, "Account.Create": true}
func AuthWrapper(fn server.HandlerFunc) server.HandlerFunc {
return func(ctx context.Context, req server.Request, resp interface{}) error {
fmt.Printf("AuthWrapper, req: %+v", req)
method := req.Method()
fmt.Printf("checking if method allowed, method: %+v", method)
if _, ok := methodsWithoutAuth[method]; ok {
return fn(ctx, req, resp)
}
fmt.Printf("validating token")
authClient := auth.NewAuthServiceClient("go.micro.srv.auth", client.DefaultClient)
meta, ok := metadata.FromContext(ctx)
if !ok {
return errors.New("no auth meta-data found in request")
}
token := meta["Token"]
log.Println("Authenticating with token: ", token)
newCtx := context.WithValue(ctx, "Method", req.Method())
_, err := authClient.ValidateToken(newCtx, &auth.Token{Token: token})
if err != nil {
return err
}
prof, err := authClient.Decode(newCtx, &auth.Token{Token: token})
if err != nil {
return err
}
newCtxWithProf := context.WithValue(newCtx, "Profile", prof.Profile)
return fn(newCtxWithProf, req, resp)
}
}

Answer 1

You can write service wrappers by incorporating the go-micro client in the wrapper code. You find on github many examples how to write a go-micro client, I believe there is one in the greeter example in the go-micro repository.
I use a wrapper to disclose a grpc-interface to a rest-service wrapper by using the client boilerplate.
You can write wrappers to a micro-service for almost any purpose in this way.
Don't worry about the ports the client code needs to address, Consul can handle this just fine for you.