meter/handler: more idiomatic option handling

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

client/options.go

@@ -170,14 +170,16 @@ func NewOptions(opts ...Option) Options {
 			RequestTimeout: DefaultRequestTimeout,
 			DialTimeout:    transport.DefaultDialTimeout,
 		},
-		Lookup:   LookupRoute,
-		PoolSize: DefaultPoolSize,
-		PoolTTL:  DefaultPoolTTL,
-		Selector: random.NewSelector(),
-		Logger:   logger.DefaultLogger,
-		Broker:   broker.DefaultBroker,
-		Meter:    meter.DefaultMeter,
-		Tracer:   tracer.DefaultTracer,
+		Lookup:    LookupRoute,
+		PoolSize:  DefaultPoolSize,
+		PoolTTL:   DefaultPoolTTL,
+		Selector:  random.NewSelector(),
+		Logger:    logger.DefaultLogger,
+		Broker:    broker.DefaultBroker,
+		Meter:     meter.DefaultMeter,
+		Tracer:    tracer.DefaultTracer,
+		Router:    router.DefaultRouter,
+		Transport: transport.DefaultTransport,
 	}
 
 	for _, o := range opts {

go.mod

@@ -9,5 +9,5 @@ require (
 	github.com/imdario/mergo v0.3.12
 	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/silas/dag v0.0.0-20210121180416-41cf55125c34
-	golang.org/x/net v0.0.0-20210324205630-d1beb07c2056
+	golang.org/x/net v0.0.0-20210326220855-61e056675ecf
 )

go.sum

@@ -10,8 +10,8 @@ github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaR
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
 github.com/silas/dag v0.0.0-20210121180416-41cf55125c34 h1:vBfVmA5mZhsQa2jr1FOL9nfA37N/jnbBmi5XUfviVTI=
 github.com/silas/dag v0.0.0-20210121180416-41cf55125c34/go.mod h1:7RTUFBdIRC9nZ7/3RyRNH1bdqIShrDejd1YbLwgPS+I=
-golang.org/x/net v0.0.0-20210324205630-d1beb07c2056 h1:sANdAef76Ioam9aQUUdcAqricwY/WUaMc4+7LY4eGg8=
-golang.org/x/net v0.0.0-20210324205630-d1beb07c2056/go.mod h1:uSPa2vr4CLtc/ILN5odXGNXS6mhrKVzTaCXzk9m6W3k=
+golang.org/x/net v0.0.0-20210326220855-61e056675ecf h1:WUcCxqQqDT0aXO4VnQbfMvp4zh7m1Gb2clVuHUAGGRE=
+golang.org/x/net v0.0.0-20210326220855-61e056675ecf/go.mod h1:uSPa2vr4CLtc/ILN5odXGNXS6mhrKVzTaCXzk9m6W3k=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=

meter/handler/handler.go

@@ -1,10 +1,11 @@
-package pb
+package handler
 
 import (
 	"bytes"
 	"context"
 
 	"github.com/unistack-org/micro/v3/codec"
+	"github.com/unistack-org/micro/v3/errors"
 	"github.com/unistack-org/micro/v3/meter"
 )
 
@@ -13,21 +14,53 @@ var (
 	_ MeterServer = &handler{}
 )
 
-type Empty struct{}
-
 type handler struct {
-	meter meter.Meter
-	opts  []meter.Option
+	opts Options
 }
 
-func NewHandler(meter meter.Meter, opts ...meter.Option) *handler {
-	return &handler{meter: meter, opts: opts}
+type Option func(*Options)
+
+type Options struct {
+	Meter        meter.Meter
+	MeterOptions []meter.Option
+	Name         string
+}
+
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+func Name(name string) Option {
+	return func(o *Options) {
+		o.Name = name
+	}
+}
+
+func MeterOptions(opts ...meter.Option) Option {
+	return func(o *Options) {
+		o.MeterOptions = append(o.MeterOptions, opts...)
+	}
+}
+
+func NewOptions(opts ...Option) Options {
+	options := Options{Meter: meter.DefaultMeter}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+func NewHandler(opts ...Option) *handler {
+	options := NewOptions(opts...)
+	return &handler{opts: options}
 }
 
 func (h *handler) Metrics(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
 	buf := bytes.NewBuffer(nil)
-	if err := h.meter.Write(buf, h.opts...); err != nil {
-		return err
+	if err := h.opts.Meter.Write(buf, h.opts.MeterOptions...); err != nil {
+		return errors.InternalServerError(h.opts.Name, "%v", err)
 	}
 
 	rsp.Data = buf.Bytes()

meter/handler/handler.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 
-package meter;
-option go_package = "github.com/unistack-org/micro/v3/meter/handler;pb";
+package micro.meter.handler;
+option go_package = "github.com/unistack-org/micro/v3/meter/handler;handler";
 
 import "api/annotations.proto";
 import "openapiv2/annotations.proto";
@@ -17,7 +17,7 @@ service Meter {
             description: "Error response";
             schema: {
               json_schema: {
-                ref: "Empty";
+                ref: "micro.codec.Frame";
               }
             }
           }

meter/handler/handler_micro.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-micro
 // source: handler.proto
-package pb
+package handler
 
 import (
 	context "context"

meter/handler/handler_micro_http.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-micro
 // source: handler.proto
-package pb
+package handler
 
 import (
 	context "context"

router/dns.go

@@ -0,0 +1,91 @@
+package router
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+)
+
+// NewRouter returns an initialized dns router
+func NewRouter(opts ...Option) Router {
+	options := NewOptions(opts...)
+	return &dns{options}
+}
+
+type dns struct {
+	options Options
+}
+
+func (d *dns) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&d.options)
+	}
+	return nil
+}
+
+func (d *dns) Options() Options {
+	return d.options
+}
+
+func (d *dns) Table() Table {
+	return nil
+}
+
+func (d *dns) Close() error {
+	return nil
+}
+
+func (d *dns) Lookup(opts ...QueryOption) ([]Route, error) {
+	options := NewQuery(opts...)
+	// check to see if we have the port provided in the service, e.g. go-micro-srv-foo:8000
+	host, port, err := net.SplitHostPort(options.Service)
+	if err == nil {
+		// lookup the service using A records
+		ips, err := net.LookupHost(host)
+		if err != nil {
+			return nil, err
+		}
+
+		p, _ := strconv.Atoi(port)
+
+		// convert the ip addresses to routes
+		result := make([]Route, len(ips))
+		for i, ip := range ips {
+			result[i] = Route{
+				Service: options.Service,
+				Address: fmt.Sprintf("%s:%d", ip, uint16(p)),
+			}
+		}
+		return result, nil
+	}
+
+	// we didn't get the port so we'll lookup the service using SRV records. If we can't lookup the
+	// service using the SRV record, we return the error.
+	_, nodes, err := net.LookupSRV(options.Service, "tcp", d.options.Network)
+	if err != nil {
+		return nil, err
+	}
+
+	// convert the nodes (net services) to routes
+	result := make([]Route, len(nodes))
+	for i, n := range nodes {
+		result[i] = Route{
+			Service: options.Service,
+			Address: fmt.Sprintf("%s:%d", n.Target, n.Port),
+			Network: d.options.Network,
+		}
+	}
+	return result, nil
+}
+
+func (d *dns) Watch(opts ...WatchOption) (Watcher, error) {
+	return nil, nil
+}
+
+func (d *dns) Name() string {
+	return d.options.Name
+}
+
+func (d *dns) String() string {
+	return "dns"
+}

router/router.go

@@ -7,7 +7,7 @@ import (
 
 var (
 	// DefaultRouter is the global default router
-	DefaultRouter Router
+	DefaultRouter Router = NewRouter()
 	// DefaultNetwork is default micro network
 	DefaultNetwork = "micro"
 	// ErrRouteNotFound is returned when no route was found in the routing table

server/generate.go

@@ -0,0 +1,3 @@
+package server
+
+//go:generate protoc -I./health -I../ -I/home/vtolstov/.cache/go-path/pkg/mod/github.com/unistack-org/micro-proto@v0.0.1 --micro_out=components=micro|http|server,standalone=false,debug=true,paths=source_relative:./health health/health.proto

server/health/health.go

@@ -0,0 +1,87 @@
+package health
+
+import (
+	"context"
+
+	"github.com/unistack-org/micro/v3/codec"
+	"github.com/unistack-org/micro/v3/errors"
+	"github.com/unistack-org/micro/v3/server"
+)
+
+var (
+	// guard to fail early
+	_ HealthServer = &handler{}
+)
+
+type handler struct {
+	server server.Server
+	opts   Options
+}
+
+type CheckFunc func(context.Context) error
+
+type Option func(*Options)
+
+type Options struct {
+	LiveChecks  []CheckFunc
+	ReadyChecks []CheckFunc
+	Version     string
+	Name        string
+}
+
+func LiveChecks(fns ...CheckFunc) Option {
+	return func(o *Options) {
+		o.LiveChecks = append(o.LiveChecks, fns...)
+	}
+}
+
+func ReadyChecks(fns ...CheckFunc) Option {
+	return func(o *Options) {
+		o.ReadyChecks = append(o.ReadyChecks, fns...)
+	}
+}
+
+func Name(name string) Option {
+	return func(o *Options) {
+		o.Name = name
+	}
+}
+
+func Version(version string) Option {
+	return func(o *Options) {
+		o.Version = version
+	}
+}
+
+func NewHandler(opts ...Option) *handler {
+	options := Options{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return &handler{opts: options}
+}
+
+func (h *handler) Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	var err error
+	for _, fn := range h.opts.LiveChecks {
+		if err = fn(ctx); err != nil {
+			return errors.ServiceUnavailable(h.opts.Name, "%v", err)
+		}
+	}
+	return nil
+}
+
+func (h *handler) Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	var err error
+	for _, fn := range h.opts.ReadyChecks {
+		if err = fn(ctx); err != nil {
+			return errors.ServiceUnavailable(h.opts.Name, "%v", err)
+		}
+	}
+	return nil
+}
+
+func (h *handler) Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	rsp.Data = []byte(h.opts.Version)
+	return nil
+}

server/health/health.proto

@@ -0,0 +1,62 @@
+syntax = "proto3";
+
+package micro.server.health;
+option go_package = "github.com/unistack-org/micro/v3/server/health;health";
+
+import "api/annotations.proto";
+import "openapiv2/annotations.proto";
+import "codec/frame.proto";
+
+service Health {
+	rpc Live(micro.codec.Frame) returns (micro.codec.Frame) {
+		option (micro.openapiv2.openapiv2_operation) = {
+      operation_id: "Live";
+        responses: {
+          key: "default";
+          value: {
+            description: "Error response";
+            schema: {
+              json_schema: {
+                ref: "micro.codec.Frame";
+              }
+            }
+          }
+        }
+    };
+		option (micro.api.http) = { get: "/live"; };
+  };
+	rpc Ready(micro.codec.Frame) returns (micro.codec.Frame) {
+		option (micro.openapiv2.openapiv2_operation) = {
+      operation_id: "Ready";
+        responses: {
+          key: "default";
+          value: {
+            description: "Error response";
+            schema: {
+              json_schema: {
+                ref: "micro.codec.Frame";
+              }
+            }
+          }
+        }
+    };
+		option (micro.api.http) = { get: "/ready"; };
+  };
+	rpc Version(micro.codec.Frame) returns (micro.codec.Frame) {
+		option (micro.openapiv2.openapiv2_operation) = {
+      operation_id: "Version";
+        responses: {
+          key: "default";
+          value: {
+            description: "Error response";
+            schema: {
+              json_schema: {
+                ref: "micro.codec.Frame";
+              }
+            }
+          }
+        }
+    };
+		option (micro.api.http) = { get: "/version"; };
+  };
+};

server/health/health_micro.pb.go

@@ -0,0 +1,38 @@
+// Code generated by protoc-gen-micro
+// source: health.proto
+package health
+
+import (
+	context "context"
+	api "github.com/unistack-org/micro/v3/api"
+	codec "github.com/unistack-org/micro/v3/codec"
+)
+
+func NewHealthEndpoints() []*api.Endpoint {
+	return []*api.Endpoint{
+		&api.Endpoint{
+			Name:    "Health.Live",
+			Path:    []string{"/live"},
+			Method:  []string{"GET"},
+			Handler: "rpc",
+		},
+		&api.Endpoint{
+			Name:    "Health.Ready",
+			Path:    []string{"/ready"},
+			Method:  []string{"GET"},
+			Handler: "rpc",
+		},
+		&api.Endpoint{
+			Name:    "Health.Version",
+			Path:    []string{"/version"},
+			Method:  []string{"GET"},
+			Handler: "rpc",
+		},
+	}
+}
+
+type HealthServer interface {
+	Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+	Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+	Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+}

server/health/health_micro_http.pb.go

@@ -0,0 +1,43 @@
+// Code generated by protoc-gen-micro
+// source: health.proto
+package health
+
+import (
+	context "context"
+	api "github.com/unistack-org/micro/v3/api"
+	codec "github.com/unistack-org/micro/v3/codec"
+	server "github.com/unistack-org/micro/v3/server"
+)
+
+type healthServer struct {
+	HealthServer
+}
+
+func (h *healthServer) Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	return h.HealthServer.Live(ctx, req, rsp)
+}
+
+func (h *healthServer) Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	return h.HealthServer.Ready(ctx, req, rsp)
+}
+
+func (h *healthServer) Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	return h.HealthServer.Version(ctx, req, rsp)
+}
+
+func RegisterHealthServer(s server.Server, sh HealthServer, opts ...server.HandlerOption) error {
+	type health interface {
+		Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+		Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+		Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+	}
+	type Health struct {
+		health
+	}
+	h := &healthServer{sh}
+	var nopts []server.HandlerOption
+	for _, endpoint := range NewHealthEndpoints() {
+		nopts = append(nopts, api.WithEndpoint(endpoint))
+	}
+	return s.Handle(s.NewHandler(&Health{h}, append(nopts, opts...)...))
+}

service.go

@@ -103,48 +103,48 @@ func (s *service) Init(opts ...Option) error {
 			// skip config as the struct not passed
 			continue
 		}
-		if err = cfg.Init(config.Context(s.opts.Context)); err != nil {
+		if err = cfg.Init(config.Context(cfg.Options().Context)); err != nil {
 			return err
 		}
 
-		if err = cfg.Load(s.opts.Context); err != nil {
+		if err = cfg.Load(cfg.Options().Context); err != nil {
 			return err
 		}
 
 	}
 
 	for _, log := range s.opts.Loggers {
-		if err = log.Init(logger.WithContext(s.opts.Context)); err != nil {
+		if err = log.Init(logger.WithContext(log.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, reg := range s.opts.Registers {
-		if err = reg.Init(register.Context(s.opts.Context)); err != nil {
+		if err = reg.Init(register.Context(reg.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, brk := range s.opts.Brokers {
-		if err = brk.Init(broker.Context(s.opts.Context)); err != nil {
+		if err = brk.Init(broker.Context(brk.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, str := range s.opts.Stores {
-		if err = str.Init(store.Context(s.opts.Context)); err != nil {
+		if err = str.Init(store.Context(str.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, srv := range s.opts.Servers {
-		if err = srv.Init(server.Context(s.opts.Context)); err != nil {
+		if err = srv.Init(server.Context(srv.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, cli := range s.opts.Clients {
-		if err = cli.Init(client.Context(s.opts.Context)); err != nil {
+		if err = cli.Init(client.Context(cli.Options().Context)); err != nil {
 			return err
 		}
 	}