github.com/micro/go-micro/v2@v2.9.1/registry/service/util.go (about)

     1  package service
     2  
     3  import (
     4  	"github.com/micro/go-micro/v2/registry"
     5  	pb "github.com/micro/go-micro/v2/registry/service/proto"
     6  )
     7  
     8  func values(v []*registry.Value) []*pb.Value {
     9  	if len(v) == 0 {
    10  		return []*pb.Value{}
    11  	}
    12  
    13  	vs := make([]*pb.Value, 0, len(v))
    14  	for _, vi := range v {
    15  		vs = append(vs, &pb.Value{
    16  			Name:   vi.Name,
    17  			Type:   vi.Type,
    18  			Values: values(vi.Values),
    19  		})
    20  	}
    21  	return vs
    22  }
    23  
    24  func toValues(v []*pb.Value) []*registry.Value {
    25  	if len(v) == 0 {
    26  		return []*registry.Value{}
    27  	}
    28  
    29  	vs := make([]*registry.Value, 0, len(v))
    30  	for _, vi := range v {
    31  		vs = append(vs, &registry.Value{
    32  			Name:   vi.Name,
    33  			Type:   vi.Type,
    34  			Values: toValues(vi.Values),
    35  		})
    36  	}
    37  	return vs
    38  }
    39  
    40  func ToProto(s *registry.Service) *pb.Service {
    41  	endpoints := make([]*pb.Endpoint, 0, len(s.Endpoints))
    42  	for _, ep := range s.Endpoints {
    43  		var request, response *pb.Value
    44  
    45  		if ep.Request != nil {
    46  			request = &pb.Value{
    47  				Name:   ep.Request.Name,
    48  				Type:   ep.Request.Type,
    49  				Values: values(ep.Request.Values),
    50  			}
    51  		}
    52  
    53  		if ep.Response != nil {
    54  			response = &pb.Value{
    55  				Name:   ep.Response.Name,
    56  				Type:   ep.Response.Type,
    57  				Values: values(ep.Response.Values),
    58  			}
    59  		}
    60  
    61  		endpoints = append(endpoints, &pb.Endpoint{
    62  			Name:     ep.Name,
    63  			Request:  request,
    64  			Response: response,
    65  			Metadata: ep.Metadata,
    66  		})
    67  	}
    68  
    69  	nodes := make([]*pb.Node, 0, len(s.Nodes))
    70  
    71  	for _, node := range s.Nodes {
    72  		nodes = append(nodes, &pb.Node{
    73  			Id:       node.Id,
    74  			Address:  node.Address,
    75  			Metadata: node.Metadata,
    76  		})
    77  	}
    78  
    79  	return &pb.Service{
    80  		Name:      s.Name,
    81  		Version:   s.Version,
    82  		Metadata:  s.Metadata,
    83  		Endpoints: endpoints,
    84  		Nodes:     nodes,
    85  		Options:   new(pb.Options),
    86  	}
    87  }
    88  
    89  func ToService(s *pb.Service) *registry.Service {
    90  	endpoints := make([]*registry.Endpoint, 0, len(s.Endpoints))
    91  	for _, ep := range s.Endpoints {
    92  		var request, response *registry.Value
    93  
    94  		if ep.Request != nil {
    95  			request = &registry.Value{
    96  				Name:   ep.Request.Name,
    97  				Type:   ep.Request.Type,
    98  				Values: toValues(ep.Request.Values),
    99  			}
   100  		}
   101  
   102  		if ep.Response != nil {
   103  			response = &registry.Value{
   104  				Name:   ep.Response.Name,
   105  				Type:   ep.Response.Type,
   106  				Values: toValues(ep.Response.Values),
   107  			}
   108  		}
   109  
   110  		endpoints = append(endpoints, &registry.Endpoint{
   111  			Name:     ep.Name,
   112  			Request:  request,
   113  			Response: response,
   114  			Metadata: ep.Metadata,
   115  		})
   116  	}
   117  
   118  	nodes := make([]*registry.Node, 0, len(s.Nodes))
   119  	for _, node := range s.Nodes {
   120  		nodes = append(nodes, &registry.Node{
   121  			Id:       node.Id,
   122  			Address:  node.Address,
   123  			Metadata: node.Metadata,
   124  		})
   125  	}
   126  
   127  	return &registry.Service{
   128  		Name:      s.Name,
   129  		Version:   s.Version,
   130  		Metadata:  s.Metadata,
   131  		Endpoints: endpoints,
   132  		Nodes:     nodes,
   133  	}
   134  }