github.com/tickoalcantara12/micro/v3@v3.0.0-20221007104245-9d75b9bcbab9/service/registry/client/client.go (about)

     1  package client
     2  
     3  import (
     4  	"time"
     5  
     6  	pb "github.com/tickoalcantara12/micro/v3/proto/registry"
     7  	"github.com/tickoalcantara12/micro/v3/service/client"
     8  	"github.com/tickoalcantara12/micro/v3/service/context"
     9  	"github.com/tickoalcantara12/micro/v3/service/errors"
    10  	"github.com/tickoalcantara12/micro/v3/service/registry"
    11  	"github.com/tickoalcantara12/micro/v3/service/registry/util"
    12  )
    13  
    14  var name = "registry"
    15  
    16  type srv struct {
    17  	opts registry.Options
    18  	// client to call registry
    19  	client pb.RegistryService
    20  }
    21  
    22  func (s *srv) callOpts() []client.CallOption {
    23  	opts := []client.CallOption{client.WithAuthToken()}
    24  
    25  	// set registry address
    26  	if len(s.opts.Addrs) > 0 {
    27  		opts = append(opts, client.WithAddress(s.opts.Addrs...))
    28  	}
    29  
    30  	// set timeout
    31  	if s.opts.Timeout > time.Duration(0) {
    32  		opts = append(opts, client.WithRequestTimeout(s.opts.Timeout))
    33  	}
    34  
    35  	s.client = pb.NewRegistryService(name, client.DefaultClient)
    36  	return opts
    37  }
    38  
    39  func (s *srv) Init(opts ...registry.Option) error {
    40  	for _, o := range opts {
    41  		o(&s.opts)
    42  	}
    43  	return nil
    44  }
    45  
    46  func (s *srv) Options() registry.Options {
    47  	return s.opts
    48  }
    49  
    50  func (s *srv) Register(srv *registry.Service, opts ...registry.RegisterOption) error {
    51  	var options registry.RegisterOptions
    52  	for _, o := range opts {
    53  		o(&options)
    54  	}
    55  
    56  	// encode srv into protobuf and pack TTL and domain into it
    57  	pbSrv := util.ToProto(srv)
    58  	pbSrv.Options.Ttl = int64(options.TTL.Seconds())
    59  	pbSrv.Options.Domain = options.Domain
    60  
    61  	// register the service
    62  	_, err := s.client.Register(context.DefaultContext, pbSrv, s.callOpts()...)
    63  	return err
    64  }
    65  
    66  func (s *srv) Deregister(srv *registry.Service, opts ...registry.DeregisterOption) error {
    67  	var options registry.DeregisterOptions
    68  	for _, o := range opts {
    69  		o(&options)
    70  	}
    71  
    72  	// encode srv into protobuf and pack domain into it
    73  	pbSrv := util.ToProto(srv)
    74  	pbSrv.Options.Domain = options.Domain
    75  
    76  	// deregister the service
    77  	_, err := s.client.Deregister(context.DefaultContext, pbSrv, s.callOpts()...)
    78  	return err
    79  }
    80  
    81  func (s *srv) GetService(name string, opts ...registry.GetOption) ([]*registry.Service, error) {
    82  	var options registry.GetOptions
    83  	for _, o := range opts {
    84  		o(&options)
    85  	}
    86  
    87  	rsp, err := s.client.GetService(context.DefaultContext, &pb.GetRequest{
    88  		Service: name, Options: &pb.Options{Domain: options.Domain},
    89  	}, s.callOpts()...)
    90  
    91  	if verr := errors.FromError(err); verr != nil && verr.Code == 404 {
    92  		return nil, registry.ErrNotFound
    93  	} else if err != nil {
    94  		return nil, err
    95  	}
    96  
    97  	services := make([]*registry.Service, 0, len(rsp.Services))
    98  	for _, service := range rsp.Services {
    99  		services = append(services, util.ToService(service))
   100  	}
   101  	return services, nil
   102  }
   103  
   104  func (s *srv) ListServices(opts ...registry.ListOption) ([]*registry.Service, error) {
   105  	var options registry.ListOptions
   106  	for _, o := range opts {
   107  		o(&options)
   108  	}
   109  
   110  	req := &pb.ListRequest{Options: &pb.Options{Domain: options.Domain}}
   111  	rsp, err := s.client.ListServices(context.DefaultContext, req, s.callOpts()...)
   112  	if err != nil {
   113  		return nil, err
   114  	}
   115  
   116  	services := make([]*registry.Service, 0, len(rsp.Services))
   117  	for _, service := range rsp.Services {
   118  		services = append(services, util.ToService(service))
   119  	}
   120  
   121  	return services, nil
   122  }
   123  
   124  func (s *srv) Watch(opts ...registry.WatchOption) (registry.Watcher, error) {
   125  	var options registry.WatchOptions
   126  	for _, o := range opts {
   127  		o(&options)
   128  	}
   129  
   130  	stream, err := s.client.Watch(context.DefaultContext, &pb.WatchRequest{
   131  		Service: options.Service, Options: &pb.Options{Domain: options.Domain},
   132  	}, s.callOpts()...)
   133  
   134  	if err != nil {
   135  		return nil, err
   136  	}
   137  
   138  	return newWatcher(stream), nil
   139  }
   140  
   141  func (s *srv) String() string {
   142  	return "service"
   143  }
   144  
   145  // NewRegistry returns a new registry service client
   146  func NewRegistry(opts ...registry.Option) registry.Registry {
   147  	var options registry.Options
   148  	for _, o := range opts {
   149  		o(&options)
   150  	}
   151  
   152  	return &srv{
   153  		opts:   options,
   154  		client: pb.NewRegistryService(name, client.DefaultClient),
   155  	}
   156  }