From 19e39546032819a4bf6c6aa1efaa6bb98ddeb19d Mon Sep 17 00:00:00 2001 From: freddygv Date: Fri, 12 Jun 2020 08:57:41 -0600 Subject: [PATCH] Move compound service names to use ServiceName type --- agent/cache-types/gateway_services_test.go | 4 +- agent/catalog_endpoint_test.go | 16 +-- agent/consul/acl.go | 6 +- agent/consul/catalog_endpoint.go | 1 + agent/consul/catalog_endpoint_test.go | 28 ++-- agent/consul/internal_endpoint.go | 2 +- agent/consul/internal_endpoint_test.go | 24 ++-- agent/consul/state/catalog.go | 98 +++++++------- agent/consul/state/catalog_test.go | 148 ++++++++++----------- agent/consul/state/config_entry.go | 12 +- agent/proxycfg/snapshot.go | 48 +++---- agent/proxycfg/state.go | 133 +++++++++--------- agent/proxycfg/state_test.go | 52 ++++---- agent/proxycfg/testing.go | 28 ++-- agent/structs/config_entry_gateways.go | 24 ++-- agent/structs/structs.go | 80 +++++++++-- agent/structs/structs_oss.go | 13 ++ agent/structs/structs_test.go | 8 +- agent/ui_endpoint.go | 2 +- agent/xds/clusters.go | 10 +- agent/xds/clusters_test.go | 28 ++-- agent/xds/endpoints.go | 6 +- agent/xds/endpoints_test.go | 24 ++-- agent/xds/listeners.go | 8 +- agent/xds/listeners_test.go | 8 +- 25 files changed, 439 insertions(+), 372 deletions(-) diff --git a/agent/cache-types/gateway_services_test.go b/agent/cache-types/gateway_services_test.go index f625add869..98faddec01 100644 --- a/agent/cache-types/gateway_services_test.go +++ b/agent/cache-types/gateway_services_test.go @@ -27,8 +27,8 @@ func TestGatewayServices(t *testing.T) { services := structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 1234, CAFile: "api/ca.crt", diff --git a/agent/catalog_endpoint_test.go b/agent/catalog_endpoint_test.go index 1b4b7bd141..13552122b6 100644 --- a/agent/catalog_endpoint_test.go +++ b/agent/catalog_endpoint_test.go @@ -1406,8 +1406,8 @@ func TestCatalog_GatewayServices_Terminating(t *testing.T) { expect := structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("terminating", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("terminating", nil), GatewayKind: structs.ServiceKindTerminatingGateway, CAFile: "api/ca.crt", CertFile: "api/client.crt", @@ -1415,8 +1415,8 @@ func TestCatalog_GatewayServices_Terminating(t *testing.T) { SNI: "my-domain", }, { - Service: structs.NewServiceID("redis", nil), - Gateway: structs.NewServiceID("terminating", nil), + Service: structs.NewServiceName("redis", nil), + Gateway: structs.NewServiceName("terminating", nil), GatewayKind: structs.ServiceKindTerminatingGateway, CAFile: "ca.crt", CertFile: "client.crt", @@ -1521,15 +1521,15 @@ func TestCatalog_GatewayServices_Ingress(t *testing.T) { expect := structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("ingress", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("ingress", nil), GatewayKind: structs.ServiceKindIngressGateway, Protocol: "tcp", Port: 8888, }, { - Service: structs.NewServiceID("redis", nil), - Gateway: structs.NewServiceID("ingress", nil), + Service: structs.NewServiceName("redis", nil), + Gateway: structs.NewServiceName("ingress", nil), GatewayKind: structs.ServiceKindIngressGateway, Protocol: "tcp", Port: 9999, diff --git a/agent/consul/acl.go b/agent/consul/acl.go index 1dc2030d65..4c6c7d00dd 100644 --- a/agent/consul/acl.go +++ b/agent/consul/acl.go @@ -1199,12 +1199,12 @@ func (f *aclFilter) allowGateway(gs *structs.GatewayService) bool { // Need read on service and gateway. Gateway may have different EnterpriseMeta so we fill authzContext twice gs.Gateway.FillAuthzContext(&authzContext) - if !f.allowService(gs.Gateway.ID, &authzContext) { + if !f.allowService(gs.Gateway.Name, &authzContext) { return false } gs.Service.FillAuthzContext(&authzContext) - if !f.allowService(gs.Service.ID, &authzContext) { + if !f.allowService(gs.Service.Name, &authzContext) { return false } return true @@ -1771,7 +1771,7 @@ func (f *aclFilter) filterGatewayServices(mappings *structs.GatewayServices) { var authzContext acl.AuthorizerContext s.Service.FillAuthzContext(&authzContext) - if f.authorizer.ServiceRead(s.Service.ID, &authzContext) != acl.Allow { + if f.authorizer.ServiceRead(s.Service.Name, &authzContext) != acl.Allow { f.logger.Debug("dropping service from result due to ACLs", "service", s.Service.String()) continue } diff --git a/agent/consul/catalog_endpoint.go b/agent/consul/catalog_endpoint.go index b9521fe16c..43dc705ea7 100644 --- a/agent/consul/catalog_endpoint.go +++ b/agent/consul/catalog_endpoint.go @@ -629,6 +629,7 @@ func (c *Catalog) GatewayServices(args *structs.ServiceSpecificRequest, reply *s } if entry != nil { found = true + break } } diff --git a/agent/consul/catalog_endpoint_test.go b/agent/consul/catalog_endpoint_test.go index 904be9d38c..a4b435ff14 100644 --- a/agent/consul/catalog_endpoint_test.go +++ b/agent/consul/catalog_endpoint_test.go @@ -2848,8 +2848,8 @@ func TestCatalog_GatewayServices_TerminatingGateway(t *testing.T) { expect := structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, CAFile: "api/ca.crt", CertFile: "api/client.crt", @@ -2857,16 +2857,16 @@ func TestCatalog_GatewayServices_TerminatingGateway(t *testing.T) { SNI: "my-domain", }, { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, CAFile: "", CertFile: "", KeyFile: "", }, { - Service: structs.NewServiceID("redis", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("redis", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, CAFile: "ca.crt", CertFile: "client.crt", @@ -3000,8 +3000,8 @@ func TestCatalog_GatewayServices_BothGateways(t *testing.T) { expect := structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, }, } @@ -3018,8 +3018,8 @@ func TestCatalog_GatewayServices_BothGateways(t *testing.T) { expect = structs.GatewayServices{ { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("ingress", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("ingress", nil), GatewayKind: structs.ServiceKindIngressGateway, Protocol: "tcp", Port: 8888, @@ -3216,13 +3216,13 @@ service "gateway" { expect := structs.GatewayServices{ { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, }, { - Service: structs.NewServiceID("db_replica", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("db_replica", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, }, } diff --git a/agent/consul/internal_endpoint.go b/agent/consul/internal_endpoint.go index 10f259837c..e02c21d9d7 100644 --- a/agent/consul/internal_endpoint.go +++ b/agent/consul/internal_endpoint.go @@ -169,7 +169,7 @@ func (m *Internal) GatewayServiceDump(args *structs.ServiceSpecificRequest, repl // Loop over the gateway <-> serviceName mappings and fetch all service instances for each var result structs.ServiceDump for _, gs := range gatewayServices { - idx, instances, err := state.CheckServiceNodes(ws, gs.Service.ID, &gs.Service.EnterpriseMeta) + idx, instances, err := state.CheckServiceNodes(ws, gs.Service.Name, &gs.Service.EnterpriseMeta) if err != nil { return err } diff --git a/agent/consul/internal_endpoint_test.go b/agent/consul/internal_endpoint_test.go index 2a7dee0d90..94f8f8199c 100644 --- a/agent/consul/internal_endpoint_test.go +++ b/agent/consul/internal_endpoint_test.go @@ -802,8 +802,8 @@ func TestInternal_GatewayServiceDump_Terminating(t *testing.T) { }, }, GatewayService: &structs.GatewayService{ - Gateway: structs.NewServiceID("terminating-gateway", nil), - Service: structs.NewServiceID("db", nil), + Gateway: structs.NewServiceName("terminating-gateway", nil), + Service: structs.NewServiceName("db", nil), GatewayKind: "terminating-gateway", }, }, @@ -834,16 +834,16 @@ func TestInternal_GatewayServiceDump_Terminating(t *testing.T) { }, }, GatewayService: &structs.GatewayService{ - Gateway: structs.NewServiceID("terminating-gateway", nil), - Service: structs.NewServiceID("db", nil), + Gateway: structs.NewServiceName("terminating-gateway", nil), + Service: structs.NewServiceName("db", nil), GatewayKind: "terminating-gateway", }, }, { // Only GatewayService should be returned when linked service isn't registered GatewayService: &structs.GatewayService{ - Gateway: structs.NewServiceID("terminating-gateway", nil), - Service: structs.NewServiceID("redis", nil), + Gateway: structs.NewServiceName("terminating-gateway", nil), + Service: structs.NewServiceName("redis", nil), GatewayKind: "terminating-gateway", CAFile: "/etc/certs/ca.pem", CertFile: "/etc/certs/cert.pem", @@ -1134,8 +1134,8 @@ func TestInternal_GatewayServiceDump_Ingress(t *testing.T) { }, }, GatewayService: &structs.GatewayService{ - Gateway: structs.NewServiceID("ingress-gateway", nil), - Service: structs.NewServiceID("db", nil), + Gateway: structs.NewServiceName("ingress-gateway", nil), + Service: structs.NewServiceName("db", nil), GatewayKind: "ingress-gateway", Port: 8888, Protocol: "tcp", @@ -1168,8 +1168,8 @@ func TestInternal_GatewayServiceDump_Ingress(t *testing.T) { }, }, GatewayService: &structs.GatewayService{ - Gateway: structs.NewServiceID("ingress-gateway", nil), - Service: structs.NewServiceID("db", nil), + Gateway: structs.NewServiceName("ingress-gateway", nil), + Service: structs.NewServiceName("db", nil), GatewayKind: "ingress-gateway", Port: 8888, Protocol: "tcp", @@ -1178,8 +1178,8 @@ func TestInternal_GatewayServiceDump_Ingress(t *testing.T) { { // Only GatewayService should be returned when upstream isn't registered GatewayService: &structs.GatewayService{ - Gateway: structs.NewServiceID("ingress-gateway", nil), - Service: structs.NewServiceID("web", nil), + Gateway: structs.NewServiceName("ingress-gateway", nil), + Service: structs.NewServiceName("web", nil), GatewayKind: "ingress-gateway", Port: 8080, Protocol: "tcp", diff --git a/agent/consul/state/catalog.go b/agent/consul/state/catalog.go index 8a0f8469aa..f24b20e4c2 100644 --- a/agent/consul/state/catalog.go +++ b/agent/consul/state/catalog.go @@ -71,10 +71,10 @@ func gatewayServicesTableNameSchema() *memdb.TableSchema { Unique: true, Indexer: &memdb.CompoundIndex{ Indexes: []memdb.Indexer{ - &ServiceIDIndex{ + &ServiceNameIndex{ Field: "Gateway", }, - &ServiceIDIndex{ + &ServiceNameIndex{ Field: "Service", }, &memdb.IntFieldIndex{ @@ -87,7 +87,7 @@ func gatewayServicesTableNameSchema() *memdb.TableSchema { Name: "gateway", AllowMissing: false, Unique: false, - Indexer: &ServiceIDIndex{ + Indexer: &ServiceNameIndex{ Field: "Gateway", }, }, @@ -95,7 +95,7 @@ func gatewayServicesTableNameSchema() *memdb.TableSchema { Name: "service", AllowMissing: true, Unique: false, - Indexer: &ServiceIDIndex{ + Indexer: &ServiceNameIndex{ Field: "Service", }, }, @@ -103,11 +103,11 @@ func gatewayServicesTableNameSchema() *memdb.TableSchema { } } -type ServiceIDIndex struct { +type ServiceNameIndex struct { Field string } -func (index *ServiceIDIndex) FromObject(obj interface{}) (bool, []byte, error) { +func (index *ServiceNameIndex) FromObject(obj interface{}) (bool, []byte, error) { v := reflect.ValueOf(obj) v = reflect.Indirect(v) // Dereference the pointer if any @@ -119,33 +119,33 @@ func (index *ServiceIDIndex) FromObject(obj interface{}) (bool, []byte, error) { fmt.Errorf("field '%s' for %#v is invalid %v ", index.Field, obj, isPtr) } - sid, ok := fv.Interface().(structs.ServiceID) + name, ok := fv.Interface().(structs.ServiceName) if !ok { - return false, nil, fmt.Errorf("Field 'ServiceID' is not of type structs.ServiceID") + return false, nil, fmt.Errorf("Field 'ServiceName' is not of type structs.ServiceName") } // Enforce lowercase and add null character as terminator - id := strings.ToLower(sid.String()) + "\x00" + id := strings.ToLower(name.String()) + "\x00" return true, []byte(id), nil } -func (index *ServiceIDIndex) FromArgs(args ...interface{}) ([]byte, error) { +func (index *ServiceNameIndex) FromArgs(args ...interface{}) ([]byte, error) { if len(args) != 1 { return nil, fmt.Errorf("must provide only a single argument") } - sid, ok := args[0].(structs.ServiceID) + name, ok := args[0].(structs.ServiceName) if !ok { - return nil, fmt.Errorf("argument must be of type structs.ServiceID: %#v", args[0]) + return nil, fmt.Errorf("argument must be of type structs.ServiceName: %#v", args[0]) } // Enforce lowercase and add null character as terminator - id := strings.ToLower(sid.String()) + "\x00" + id := strings.ToLower(name.String()) + "\x00" return []byte(strings.ToLower(id)), nil } -func (index *ServiceIDIndex) PrefixFromArgs(args ...interface{}) ([]byte, error) { +func (index *ServiceNameIndex) PrefixFromArgs(args ...interface{}) ([]byte, error) { val, err := index.FromArgs(args...) if err != nil { return nil, err @@ -872,7 +872,7 @@ func (s *Store) serviceListTxn(tx *memdb.Txn, ws memdb.WatchSet, entMeta *struct } ws.Add(services.WatchCh()) - unique := make(map[structs.ServiceID]struct{}) + unique := make(map[structs.ServiceName]struct{}) for service := services.Next(); service != nil; service = services.Next() { svc := service.(*structs.ServiceNode) unique[svc.CompoundServiceName()] = struct{}{} @@ -880,7 +880,7 @@ func (s *Store) serviceListTxn(tx *memdb.Txn, ws memdb.WatchSet, entMeta *struct results := make(structs.ServiceList, 0, len(unique)) for sid, _ := range unique { - results = append(results, structs.ServiceName{Name: sid.ID, EnterpriseMeta: sid.EnterpriseMeta}) + results = append(results, structs.ServiceName{Name: sid.Name, EnterpriseMeta: sid.EnterpriseMeta}) } return idx, results, nil @@ -1009,18 +1009,18 @@ func (s *Store) maxIndexAndWatchChsForServiceNodes(tx *memdb.Txn, var watchChans []<-chan struct{} var maxIdx uint64 - seen := make(map[structs.ServiceID]bool) + seen := make(map[structs.ServiceName]bool) for i := 0; i < len(nodes); i++ { - sid := structs.NewServiceID(nodes[i].ServiceName, &nodes[i].EnterpriseMeta) - if ok := seen[sid]; !ok { - idx, svcCh := s.maxIndexAndWatchChForService(tx, sid.ID, true, watchChecks, &sid.EnterpriseMeta) + sn := structs.NewServiceName(nodes[i].ServiceName, &nodes[i].EnterpriseMeta) + if ok := seen[sn]; !ok { + idx, svcCh := s.maxIndexAndWatchChForService(tx, sn.Name, true, watchChecks, &sn.EnterpriseMeta) if idx > maxIdx { maxIdx = idx } if svcCh != nil { watchChans = append(watchChans, svcCh) } - seen[sid] = true + seen[sn] = true } } @@ -2014,14 +2014,14 @@ func (s *Store) CheckIngressServiceNodes(ws memdb.WatchSet, serviceName string, // TODO(ingress): Test namespace functionality here // De-dup services to lookup - serviceIDs := make(map[structs.ServiceID]struct{}) + names := make(map[structs.ServiceName]struct{}) for _, n := range nodes { - serviceIDs[n.CompoundServiceName()] = struct{}{} + names[n.CompoundServiceName()] = struct{}{} } var results structs.CheckServiceNodes - for sid := range serviceIDs { - idx, n, err := s.checkServiceNodesTxn(tx, ws, sid.ID, false, &sid.EnterpriseMeta) + for sid := range names { + idx, n, err := s.checkServiceNodesTxn(tx, ws, sid.Name, false, &sid.EnterpriseMeta) if err != nil { return 0, nil, err } @@ -2065,13 +2065,13 @@ func (s *Store) checkServiceNodesTxn(tx *memdb.Txn, ws memdb.WatchSet, serviceNa // service name IFF there is at least one Connect-native instance of that // service. Either way there is usually only one distinct name if proxies are // named consistently but could be multiple. - serviceNames := make(map[structs.ServiceID]struct{}, 2) + serviceNames := make(map[structs.ServiceName]struct{}, 2) for service := iter.Next(); service != nil; service = iter.Next() { sn := service.(*structs.ServiceNode) results = append(results, sn) - sid := structs.NewServiceID(sn.ServiceName, &sn.EnterpriseMeta) - serviceNames[sid] = struct{}{} + name := structs.NewServiceName(sn.ServiceName, &sn.EnterpriseMeta) + serviceNames[name] = struct{}{} } // If we are querying for Connect nodes, the associated proxy might be a terminating-gateway. @@ -2089,8 +2089,8 @@ func (s *Store) checkServiceNodesTxn(tx *memdb.Txn, ws memdb.WatchSet, serviceNa for i := 0; i < len(nodes); i++ { results = append(results, nodes[i]) - sid := structs.NewServiceID(nodes[i].ServiceName, &nodes[i].EnterpriseMeta) - serviceNames[sid] = struct{}{} + name := structs.NewServiceName(nodes[i].ServiceName, &nodes[i].EnterpriseMeta) + serviceNames[name] = struct{}{} } } @@ -2109,11 +2109,11 @@ func (s *Store) checkServiceNodesTxn(tx *memdb.Txn, ws memdb.WatchSet, serviceNa watchOptimized = true // Fetch indexes for all names services in result set. - for svcName := range serviceNames { + for n := range serviceNames { // We know service values should exist since the serviceNames map is only // populated if there is at least one result above. so serviceExists arg // below is always true. - svcIdx, svcCh := s.maxIndexAndWatchChForService(tx, svcName.ID, true, true, &svcName.EnterpriseMeta) + svcIdx, svcCh := s.maxIndexAndWatchChForService(tx, n.Name, true, true, &n.EnterpriseMeta) // Take the max index represented idx = lib.MaxUint64(idx, svcIdx) if svcCh != nil { @@ -2208,7 +2208,7 @@ func (s *Store) GatewayServices(ws memdb.WatchSet, gateway string, entMeta *stru for service := iter.Next(); service != nil; service = iter.Next() { svc := service.(*structs.GatewayService) - if svc.Service.ID != structs.WildcardSpecifier { + if svc.Service.Name != structs.WildcardSpecifier { idx, matches, err := s.checkProtocolMatch(tx, ws, svc) if err != nil { return 0, nil, fmt.Errorf("failed checking protocol: %s", err) @@ -2476,12 +2476,12 @@ func (s *Store) updateGatewayServices(tx *memdb.Txn, idx uint64, conf structs.Co err error ) - gatewayID := structs.NewServiceID(conf.GetName(), entMeta) + gateway := structs.NewServiceName(conf.GetName(), entMeta) switch conf.GetKind() { case structs.IngressGateway: - noChange, gatewayServices, err = s.ingressConfigGatewayServices(tx, gatewayID, conf, entMeta) + noChange, gatewayServices, err = s.ingressConfigGatewayServices(tx, gateway, conf, entMeta) case structs.TerminatingGateway: - noChange, gatewayServices, err = s.terminatingConfigGatewayServices(tx, gatewayID, conf, entMeta) + noChange, gatewayServices, err = s.terminatingConfigGatewayServices(tx, gateway, conf, entMeta) default: return fmt.Errorf("config entry kind %q does not need gateway-services", conf.GetKind()) } @@ -2491,15 +2491,15 @@ func (s *Store) updateGatewayServices(tx *memdb.Txn, idx uint64, conf structs.Co } // Delete all associated with gateway first, to avoid keeping mappings that were removed - if _, err := tx.DeleteAll(gatewayServicesTableName, "gateway", structs.NewServiceID(conf.GetName(), entMeta)); err != nil { + if _, err := tx.DeleteAll(gatewayServicesTableName, "gateway", structs.NewServiceName(conf.GetName(), entMeta)); err != nil { return fmt.Errorf("failed to truncate gateway services table: %v", err) } for _, svc := range gatewayServices { // If the service is a wildcard we need to target all services within the namespace - if svc.Service.ID == structs.WildcardSpecifier { + if svc.Service.Name == structs.WildcardSpecifier { if err := s.updateGatewayNamespace(tx, idx, svc, entMeta); err != nil { - return fmt.Errorf("failed to associate gateway %q with wildcard: %v", gatewayID.String(), err) + return fmt.Errorf("failed to associate gateway %q with wildcard: %v", gateway.String(), err) } // Skip service-specific update below if there was a wildcard update continue @@ -2527,7 +2527,7 @@ func (s *Store) updateGatewayServices(tx *memdb.Txn, idx uint64, conf structs.Co // returned indicates that there are no changes necessary to the memdb table. func (s *Store) ingressConfigGatewayServices( tx *memdb.Txn, - gateway structs.ServiceID, + gateway structs.ServiceName, conf structs.ConfigEntry, entMeta *structs.EnterpriseMeta, ) (bool, structs.GatewayServices, error) { @@ -2553,7 +2553,7 @@ func (s *Store) ingressConfigGatewayServices( for _, service := range listener.Services { mapping := &structs.GatewayService{ Gateway: gateway, - Service: service.ToServiceID(), + Service: service.ToServiceName(), GatewayKind: structs.ServiceKindIngressGateway, Hosts: service.Hosts, Port: listener.Port, @@ -2572,7 +2572,7 @@ func (s *Store) ingressConfigGatewayServices( // table. func (s *Store) terminatingConfigGatewayServices( tx *memdb.Txn, - gateway structs.ServiceID, + gateway structs.ServiceName, conf structs.ConfigEntry, entMeta *structs.EnterpriseMeta, ) (bool, structs.GatewayServices, error) { @@ -2597,7 +2597,7 @@ func (s *Store) terminatingConfigGatewayServices( for _, svc := range entry.Services { mapping := &structs.GatewayService{ Gateway: gateway, - Service: structs.NewServiceID(svc.Name, &svc.EnterpriseMeta), + Service: structs.NewServiceName(svc.Name, &svc.EnterpriseMeta), GatewayKind: structs.ServiceKindTerminatingGateway, KeyFile: svc.KeyFile, CertFile: svc.CertFile, @@ -2638,7 +2638,7 @@ func (s *Store) updateGatewayNamespace(tx *memdb.Txn, idx uint64, service *struc mapping := service.Clone() - mapping.Service = structs.NewServiceID(sn.ServiceName, &service.Service.EnterpriseMeta) + mapping.Service = structs.NewServiceName(sn.ServiceName, &service.Service.EnterpriseMeta) mapping.FromWildcard = true err = s.updateGatewayService(tx, idx, mapping) @@ -2705,7 +2705,7 @@ func (s *Store) checkGatewayWildcardsAndUpdate(tx *memdb.Txn, idx uint64, svc *s // Copy the wildcard mapping and modify it gatewaySvc := wildcardSvc.Clone() - gatewaySvc.Service = structs.NewServiceID(svc.Service, &svc.EnterpriseMeta) + gatewaySvc.Service = structs.NewServiceName(svc.Service, &svc.EnterpriseMeta) gatewaySvc.FromWildcard = true if err = s.updateGatewayService(tx, idx, gatewaySvc); err != nil { @@ -2719,11 +2719,11 @@ func (s *Store) checkGatewayWildcardsAndUpdate(tx *memdb.Txn, idx uint64, svc *s // serviceGateways returns all GatewayService entries with the given service name. This effectively looks up // all the gateways mapped to this service. func (s *Store) serviceGateways(tx *memdb.Txn, name string, entMeta *structs.EnterpriseMeta) (memdb.ResultIterator, error) { - return tx.Get(gatewayServicesTableName, "service", structs.NewServiceID(name, entMeta)) + return tx.Get(gatewayServicesTableName, "service", structs.NewServiceName(name, entMeta)) } func (s *Store) gatewayServices(tx *memdb.Txn, name string, entMeta *structs.EnterpriseMeta) (memdb.ResultIterator, error) { - return tx.Get(gatewayServicesTableName, "gateway", structs.NewServiceID(name, entMeta)) + return tx.Get(gatewayServicesTableName, "gateway", structs.NewServiceName(name, entMeta)) } // TODO(ingress): How to handle index rolling back when a config entry is @@ -2752,7 +2752,7 @@ func (s *Store) serviceGatewayNodes(tx *memdb.Txn, ws memdb.WatchSet, service st maxIdx = lib.MaxUint64(maxIdx, mapping.ModifyIndex) // Look up nodes for gateway - gwServices, err := s.catalogServiceNodeList(tx, mapping.Gateway.ID, "service", &mapping.Gateway.EnterpriseMeta) + gwServices, err := s.catalogServiceNodeList(tx, mapping.Gateway.Name, "service", &mapping.Gateway.EnterpriseMeta) if err != nil { return 0, nil, fmt.Errorf("failed service lookup: %s", err) } @@ -2767,7 +2767,7 @@ func (s *Store) serviceGatewayNodes(tx *memdb.Txn, ws memdb.WatchSet, service st } // This prevents the index from sliding back if case all instances of the gateway service are deregistered - svcIdx := s.maxIndexForService(tx, mapping.Gateway.ID, exists, false, &mapping.Gateway.EnterpriseMeta) + svcIdx := s.maxIndexForService(tx, mapping.Gateway.Name, exists, false, &mapping.Gateway.EnterpriseMeta) maxIdx = lib.MaxUint64(maxIdx, svcIdx) // Ensure that blocking queries wake up if the gateway-service mapping exists, but the gateway does not exist yet diff --git a/agent/consul/state/catalog_test.go b/agent/consul/state/catalog_test.go index 1a7aacec62..bc0c052947 100644 --- a/agent/consul/state/catalog_test.go +++ b/agent/consul/state/catalog_test.go @@ -4492,8 +4492,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { expect := structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, RaftIndex: structs.RaftIndex{ CreateIndex: 21, @@ -4501,8 +4501,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { }, }, { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, RaftIndex: structs.RaftIndex{ CreateIndex: 21, @@ -4534,8 +4534,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { expect = structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, RaftIndex: structs.RaftIndex{ CreateIndex: 21, @@ -4543,8 +4543,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { }, }, { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, RaftIndex: structs.RaftIndex{ CreateIndex: 21, @@ -4589,8 +4589,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { expect = structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, CAFile: "api/ca.crt", CertFile: "api/client.crt", @@ -4602,8 +4602,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { }, }, { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, RaftIndex: structs.RaftIndex{ CreateIndex: 22, @@ -4625,8 +4625,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { expect = structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, CAFile: "api/ca.crt", CertFile: "api/client.crt", @@ -4638,8 +4638,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { }, }, { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, RaftIndex: structs.RaftIndex{ CreateIndex: 22, @@ -4647,8 +4647,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { }, }, { - Service: structs.NewServiceID("redis", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("redis", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, CAFile: "ca.crt", CertFile: "client.crt", @@ -4675,8 +4675,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { expect = structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, CAFile: "api/ca.crt", CertFile: "api/client.crt", @@ -4688,8 +4688,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { }, }, { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, RaftIndex: structs.RaftIndex{ CreateIndex: 22, @@ -4719,8 +4719,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { // previously associated services should not be present expect = structs.GatewayServices{ { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, RaftIndex: structs.RaftIndex{ CreateIndex: 25, @@ -4749,8 +4749,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { expect = structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("gateway2", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("gateway2", nil), GatewayKind: structs.ServiceKindTerminatingGateway, FromWildcard: true, RaftIndex: structs.RaftIndex{ @@ -4759,8 +4759,8 @@ func TestStateStore_GatewayServices_Terminating(t *testing.T) { }, }, { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("gateway2", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("gateway2", nil), GatewayKind: structs.ServiceKindTerminatingGateway, FromWildcard: true, RaftIndex: structs.RaftIndex{ @@ -4845,8 +4845,8 @@ func TestStateStore_GatewayServices_ServiceDeletion(t *testing.T) { expect := structs.GatewayServices{ { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, CAFile: "my_ca.pem", RaftIndex: structs.RaftIndex{ @@ -4866,8 +4866,8 @@ func TestStateStore_GatewayServices_ServiceDeletion(t *testing.T) { expect = structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("other-gateway", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("other-gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, FromWildcard: true, RaftIndex: structs.RaftIndex{ @@ -4876,8 +4876,8 @@ func TestStateStore_GatewayServices_ServiceDeletion(t *testing.T) { }, }, { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("other-gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("other-gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, FromWildcard: true, RaftIndex: structs.RaftIndex{ @@ -4903,8 +4903,8 @@ func TestStateStore_GatewayServices_ServiceDeletion(t *testing.T) { expect = structs.GatewayServices{ { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, CAFile: "my_ca.pem", RaftIndex: structs.RaftIndex{ @@ -4923,8 +4923,8 @@ func TestStateStore_GatewayServices_ServiceDeletion(t *testing.T) { expect = structs.GatewayServices{ { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("other-gateway", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("other-gateway", nil), GatewayKind: structs.ServiceKindTerminatingGateway, FromWildcard: true, RaftIndex: structs.RaftIndex{ @@ -5016,8 +5016,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { t.Run("ingress1 gateway services", func(t *testing.T) { expected := structs.GatewayServices{ { - Gateway: structs.NewServiceID("ingress1", nil), - Service: structs.NewServiceID("service1", nil), + Gateway: structs.NewServiceName("ingress1", nil), + Service: structs.NewServiceName("service1", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 1111, Protocol: "http", @@ -5028,8 +5028,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { }, }, { - Gateway: structs.NewServiceID("ingress1", nil), - Service: structs.NewServiceID("service2", nil), + Gateway: structs.NewServiceName("ingress1", nil), + Service: structs.NewServiceName("service2", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 2222, Protocol: "http", @@ -5048,8 +5048,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { t.Run("ingress2 gateway services", func(t *testing.T) { expected := structs.GatewayServices{ { - Gateway: structs.NewServiceID("ingress2", nil), - Service: structs.NewServiceID("service1", nil), + Gateway: structs.NewServiceName("ingress2", nil), + Service: structs.NewServiceName("service1", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 3333, Protocol: "http", @@ -5075,8 +5075,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { t.Run("wildcard gateway services", func(t *testing.T) { expected := structs.GatewayServices{ { - Gateway: structs.NewServiceID("wildcardIngress", nil), - Service: structs.NewServiceID("service1", nil), + Gateway: structs.NewServiceName("wildcardIngress", nil), + Service: structs.NewServiceName("service1", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 4444, Protocol: "http", @@ -5087,8 +5087,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { }, }, { - Gateway: structs.NewServiceID("wildcardIngress", nil), - Service: structs.NewServiceID("service2", nil), + Gateway: structs.NewServiceName("wildcardIngress", nil), + Service: structs.NewServiceName("service2", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 4444, Protocol: "http", @@ -5099,8 +5099,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { }, }, { - Gateway: structs.NewServiceID("wildcardIngress", nil), - Service: structs.NewServiceID("service3", nil), + Gateway: structs.NewServiceName("wildcardIngress", nil), + Service: structs.NewServiceName("service3", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 4444, Protocol: "http", @@ -5120,8 +5120,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { t.Run("gateway with duplicate service", func(t *testing.T) { expected := structs.GatewayServices{ { - Gateway: structs.NewServiceID("ingress3", nil), - Service: structs.NewServiceID("service1", nil), + Gateway: structs.NewServiceName("ingress3", nil), + Service: structs.NewServiceName("service1", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 5555, Protocol: "http", @@ -5132,8 +5132,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { }, }, { - Gateway: structs.NewServiceID("ingress3", nil), - Service: structs.NewServiceID("service2", nil), + Gateway: structs.NewServiceName("ingress3", nil), + Service: structs.NewServiceName("service2", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 5555, Protocol: "http", @@ -5144,8 +5144,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { }, }, { - Gateway: structs.NewServiceID("ingress3", nil), - Service: structs.NewServiceID("service3", nil), + Gateway: structs.NewServiceName("ingress3", nil), + Service: structs.NewServiceName("service3", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 5555, Protocol: "http", @@ -5156,8 +5156,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { }, }, { - Gateway: structs.NewServiceID("ingress3", nil), - Service: structs.NewServiceID("service1", nil), + Gateway: structs.NewServiceName("ingress3", nil), + Service: structs.NewServiceName("service1", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 6666, Protocol: "http", @@ -5187,8 +5187,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { t.Run("check ingress2 gateway services again", func(t *testing.T) { expected := structs.GatewayServices{ { - Gateway: structs.NewServiceID("ingress2", nil), - Service: structs.NewServiceID("service1", nil), + Gateway: structs.NewServiceName("ingress2", nil), + Service: structs.NewServiceName("service1", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 3333, Protocol: "http", @@ -5256,8 +5256,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { expected := structs.GatewayServices{ { - Gateway: structs.NewServiceID("ingress1", nil), - Service: structs.NewServiceID("service1", nil), + Gateway: structs.NewServiceName("ingress1", nil), + Service: structs.NewServiceName("service1", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 1111, Protocol: "http", @@ -5268,8 +5268,8 @@ func TestStateStore_GatewayServices_Ingress(t *testing.T) { }, }, { - Gateway: structs.NewServiceID("ingress1", nil), - Service: structs.NewServiceID("service2", nil), + Gateway: structs.NewServiceName("ingress1", nil), + Service: structs.NewServiceName("service2", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 2222, Protocol: "http", @@ -5400,8 +5400,8 @@ func TestStateStore_GatewayServices_IngressProtocolFiltering(t *testing.T) { require := require.New(t) expected := structs.GatewayServices{ { - Gateway: structs.NewServiceID("ingress1", nil), - Service: structs.NewServiceID("service1", nil), + Gateway: structs.NewServiceName("ingress1", nil), + Service: structs.NewServiceName("service1", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 4444, Protocol: "http", @@ -5429,8 +5429,8 @@ func TestStateStore_GatewayServices_IngressProtocolFiltering(t *testing.T) { require := require.New(t) expected := structs.GatewayServices{ { - Gateway: structs.NewServiceID("ingress1", nil), - Service: structs.NewServiceID("service1", nil), + Gateway: structs.NewServiceName("ingress1", nil), + Service: structs.NewServiceName("service1", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 4444, Protocol: "http", @@ -5441,8 +5441,8 @@ func TestStateStore_GatewayServices_IngressProtocolFiltering(t *testing.T) { }, }, { - Gateway: structs.NewServiceID("ingress1", nil), - Service: structs.NewServiceID("service2", nil), + Gateway: structs.NewServiceName("ingress1", nil), + Service: structs.NewServiceName("service2", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 4444, Protocol: "http", @@ -5473,8 +5473,8 @@ func TestStateStore_GatewayServices_IngressProtocolFiltering(t *testing.T) { require := require.New(t) expected := structs.GatewayServices{ { - Gateway: structs.NewServiceID("ingress1", nil), - Service: structs.NewServiceID("service2", nil), + Gateway: structs.NewServiceName("ingress1", nil), + Service: structs.NewServiceName("service2", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 4444, Protocol: "http", @@ -5503,8 +5503,8 @@ func TestStateStore_GatewayServices_IngressProtocolFiltering(t *testing.T) { require := require.New(t) expected := structs.GatewayServices{ { - Gateway: structs.NewServiceID("ingress1", nil), - Service: structs.NewServiceID("service1", nil), + Gateway: structs.NewServiceName("ingress1", nil), + Service: structs.NewServiceName("service1", nil), GatewayKind: structs.ServiceKindIngressGateway, Port: 4444, Protocol: "grpc", diff --git a/agent/consul/state/config_entry.go b/agent/consul/state/config_entry.go index a59f572534..1fbaea78be 100644 --- a/agent/consul/state/config_entry.go +++ b/agent/consul/state/config_entry.go @@ -266,7 +266,7 @@ func (s *Store) DeleteConfigEntry(idx uint64, kind, name string, entMeta *struct // If the config entry is for terminating or ingress gateways we delete entries from the memdb table // that associates gateways <-> services. if kind == structs.TerminatingGateway || kind == structs.IngressGateway { - if _, err := tx.DeleteAll(gatewayServicesTableName, "gateway", structs.NewServiceID(name, entMeta)); err != nil { + if _, err := tx.DeleteAll(gatewayServicesTableName, "gateway", structs.NewServiceName(name, entMeta)); err != nil { return fmt.Errorf("failed to truncate gateway services table: %v", err) } if err := indexUpdateMaxTxn(tx, idx, gatewayServicesTableName); err != nil { @@ -855,7 +855,7 @@ func (s *Store) validateProposedIngressProtocolsInServiceGraph( return fmt.Errorf("type %T is not an ingress gateway config entry", next) } - validationFn := func(svc structs.ServiceID, expectedProto string) error { + validationFn := func(svc structs.ServiceName, expectedProto string) error { _, svcProto, err := s.protocolForService(tx, nil, svc) if err != nil { return err @@ -874,7 +874,7 @@ func (s *Store) validateProposedIngressProtocolsInServiceGraph( if s.Name == structs.WildcardSpecifier { continue } - err := validationFn(s.ToServiceID(), l.Protocol) + err := validationFn(s.ToServiceName(), l.Protocol) if err != nil { return err } @@ -888,7 +888,7 @@ func (s *Store) validateProposedIngressProtocolsInServiceGraph( func (s *Store) protocolForService( tx *memdb.Txn, ws memdb.WatchSet, - svc structs.ServiceID, + svc structs.ServiceName, ) (uint64, string, error) { // Get the global proxy defaults (for default protocol) maxIdx, proxyConfig, err := s.configEntryTxn(tx, ws, structs.ProxyDefaults, structs.ProxyConfigGlobal, structs.DefaultEnterpriseMeta()) @@ -896,7 +896,7 @@ func (s *Store) protocolForService( return 0, "", err } - idx, serviceDefaults, err := s.configEntryTxn(tx, ws, structs.ServiceDefaults, svc.ID, &svc.EnterpriseMeta) + idx, serviceDefaults, err := s.configEntryTxn(tx, ws, structs.ServiceDefaults, svc.Name, &svc.EnterpriseMeta) if err != nil { return 0, "", err } @@ -910,7 +910,7 @@ func (s *Store) protocolForService( entries.AddEntries(serviceDefaults) } req := discoverychain.CompileRequest{ - ServiceName: svc.ID, + ServiceName: svc.Name, EvaluateInNamespace: svc.NamespaceOrDefault(), EvaluateInDatacenter: "dc1", // Use a dummy trust domain since that won't affect the protocol here. diff --git a/agent/proxycfg/snapshot.go b/agent/proxycfg/snapshot.go index 929e75a970..2ae7f1b231 100644 --- a/agent/proxycfg/snapshot.go +++ b/agent/proxycfg/snapshot.go @@ -59,51 +59,51 @@ func (c *configSnapshotConnectProxy) IsEmpty() bool { } type configSnapshotTerminatingGateway struct { - // WatchedServices is a map of service id to a cancel function. This cancel + // WatchedServices is a map of service name to a cancel function. This cancel // function is tied to the watch of linked service instances for the given // id. If the linked services watch would indicate the removal of // a service altogether we then cancel watching that service for its endpoints. - WatchedServices map[structs.ServiceID]context.CancelFunc + WatchedServices map[structs.ServiceName]context.CancelFunc - // WatchedIntentions is a map of service id to a cancel function. + // WatchedIntentions is a map of service name to a cancel function. // This cancel function is tied to the watch of intentions for linked services. // As with WatchedServices, intention watches will be cancelled when services // are no longer linked to the gateway. - WatchedIntentions map[structs.ServiceID]context.CancelFunc + WatchedIntentions map[structs.ServiceName]context.CancelFunc - // WatchedLeaves is a map of ServiceID to a cancel function. + // WatchedLeaves is a map of ServiceName to a cancel function. // This cancel function is tied to the watch of leaf certs for linked services. // As with WatchedServices, leaf watches will be cancelled when services // are no longer linked to the gateway. - WatchedLeaves map[structs.ServiceID]context.CancelFunc + WatchedLeaves map[structs.ServiceName]context.CancelFunc - // ServiceLeaves is a map of ServiceID to a leaf cert. + // ServiceLeaves is a map of ServiceName to a leaf cert. // Terminating gateways will present different certificates depending // on the service that the caller is trying to reach. - ServiceLeaves map[structs.ServiceID]*structs.IssuedCert + ServiceLeaves map[structs.ServiceName]*structs.IssuedCert - // WatchedResolvers is a map of ServiceID to a cancel function. + // WatchedResolvers is a map of ServiceName to a cancel function. // This cancel function is tied to the watch of resolvers for linked services. // As with WatchedServices, resolver watches will be cancelled when services // are no longer linked to the gateway. - WatchedResolvers map[structs.ServiceID]context.CancelFunc + WatchedResolvers map[structs.ServiceName]context.CancelFunc - // ServiceResolvers is a map of service id to an associated + // ServiceResolvers is a map of service name to an associated // service-resolver config entry for that service. - ServiceResolvers map[structs.ServiceID]*structs.ServiceResolverConfigEntry + ServiceResolvers map[structs.ServiceName]*structs.ServiceResolverConfigEntry - // ServiceGroups is a map of service id to the service instances of that + // ServiceGroups is a map of service name to the service instances of that // service in the local datacenter. - ServiceGroups map[structs.ServiceID]structs.CheckServiceNodes + ServiceGroups map[structs.ServiceName]structs.CheckServiceNodes - // GatewayServices is a map of service id to the config entry association + // GatewayServices is a map of service name to the config entry association // between the gateway and a service. TLS configuration stored here is // used for TLS origination from the gateway to the linked service. - GatewayServices map[structs.ServiceID]structs.GatewayService + GatewayServices map[structs.ServiceName]structs.GatewayService - // HostnameServices is a map of service id to service instances with a hostname as the address. + // HostnameServices is a map of service name to service instances with a hostname as the address. // If hostnames are configured they must be provided to Envoy via CDS not EDS. - HostnameServices map[structs.ServiceID]structs.CheckServiceNodes + HostnameServices map[structs.ServiceName]structs.CheckServiceNodes } func (c *configSnapshotTerminatingGateway) IsEmpty() bool { @@ -122,12 +122,12 @@ func (c *configSnapshotTerminatingGateway) IsEmpty() bool { } type configSnapshotMeshGateway struct { - // WatchedServices is a map of service id to a cancel function. This cancel + // WatchedServices is a map of service name to a cancel function. This cancel // function is tied to the watch of connect enabled services for the given // id. If the main datacenter services watch would indicate the removal of // a service altogether we then cancel watching that service for its // connect endpoints. - WatchedServices map[structs.ServiceID]context.CancelFunc + WatchedServices map[structs.ServiceName]context.CancelFunc // WatchedServicesSet indicates that the watch on the datacenters services // has completed. Even when there are no connect services, this being set @@ -142,13 +142,13 @@ type configSnapshotMeshGateway struct { // that datacenter. WatchedDatacenters map[string]context.CancelFunc - // ServiceGroups is a map of service id to the service instances of that + // ServiceGroups is a map of service name to the service instances of that // service in the local datacenter. - ServiceGroups map[structs.ServiceID]structs.CheckServiceNodes + ServiceGroups map[structs.ServiceName]structs.CheckServiceNodes - // ServiceResolvers is a map of service id to an associated + // ServiceResolvers is a map of service name to an associated // service-resolver config entry for that service. - ServiceResolvers map[structs.ServiceID]*structs.ServiceResolverConfigEntry + ServiceResolvers map[structs.ServiceName]*structs.ServiceResolverConfigEntry // GatewayGroups is a map of datacenter names to services of kind // mesh-gateway in that datacenter. diff --git a/agent/proxycfg/state.go b/agent/proxycfg/state.go index 7f46177ea1..db62075ffc 100644 --- a/agent/proxycfg/state.go +++ b/agent/proxycfg/state.go @@ -545,21 +545,21 @@ func (s *state) initialConfigSnapshot() ConfigSnapshot { snap.ConnectProxy.WatchedServiceChecks = make(map[structs.ServiceID][]structs.CheckType) snap.ConnectProxy.PreparedQueryEndpoints = make(map[string]structs.CheckServiceNodes) case structs.ServiceKindTerminatingGateway: - snap.TerminatingGateway.WatchedServices = make(map[structs.ServiceID]context.CancelFunc) - snap.TerminatingGateway.WatchedLeaves = make(map[structs.ServiceID]context.CancelFunc) - snap.TerminatingGateway.WatchedIntentions = make(map[structs.ServiceID]context.CancelFunc) - snap.TerminatingGateway.WatchedResolvers = make(map[structs.ServiceID]context.CancelFunc) - snap.TerminatingGateway.ServiceLeaves = make(map[structs.ServiceID]*structs.IssuedCert) - snap.TerminatingGateway.ServiceGroups = make(map[structs.ServiceID]structs.CheckServiceNodes) - snap.TerminatingGateway.ServiceResolvers = make(map[structs.ServiceID]*structs.ServiceResolverConfigEntry) - snap.TerminatingGateway.GatewayServices = make(map[structs.ServiceID]structs.GatewayService) - snap.TerminatingGateway.HostnameServices = make(map[structs.ServiceID]structs.CheckServiceNodes) + snap.TerminatingGateway.WatchedServices = make(map[structs.ServiceName]context.CancelFunc) + snap.TerminatingGateway.WatchedLeaves = make(map[structs.ServiceName]context.CancelFunc) + snap.TerminatingGateway.WatchedIntentions = make(map[structs.ServiceName]context.CancelFunc) + snap.TerminatingGateway.WatchedResolvers = make(map[structs.ServiceName]context.CancelFunc) + snap.TerminatingGateway.ServiceLeaves = make(map[structs.ServiceName]*structs.IssuedCert) + snap.TerminatingGateway.ServiceGroups = make(map[structs.ServiceName]structs.CheckServiceNodes) + snap.TerminatingGateway.ServiceResolvers = make(map[structs.ServiceName]*structs.ServiceResolverConfigEntry) + snap.TerminatingGateway.GatewayServices = make(map[structs.ServiceName]structs.GatewayService) + snap.TerminatingGateway.HostnameServices = make(map[structs.ServiceName]structs.CheckServiceNodes) case structs.ServiceKindMeshGateway: - snap.MeshGateway.WatchedServices = make(map[structs.ServiceID]context.CancelFunc) + snap.MeshGateway.WatchedServices = make(map[structs.ServiceName]context.CancelFunc) snap.MeshGateway.WatchedDatacenters = make(map[string]context.CancelFunc) - snap.MeshGateway.ServiceGroups = make(map[structs.ServiceID]structs.CheckServiceNodes) + snap.MeshGateway.ServiceGroups = make(map[structs.ServiceName]structs.CheckServiceNodes) snap.MeshGateway.GatewayGroups = make(map[string]structs.CheckServiceNodes) - snap.MeshGateway.ServiceResolvers = make(map[structs.ServiceID]*structs.ServiceResolverConfigEntry) + snap.MeshGateway.ServiceResolvers = make(map[structs.ServiceName]*structs.ServiceResolverConfigEntry) snap.MeshGateway.HostnameDatacenters = make(map[string]structs.CheckServiceNodes) // there is no need to initialize the map of service resolvers as we // fully rebuild it every time we get updates @@ -921,7 +921,7 @@ func (s *state) handleUpdateTerminatingGateway(u cache.UpdateEvent, snap *Config return fmt.Errorf("invalid type for response: %T", u.Result) } - svcMap := make(map[structs.ServiceID]struct{}) + svcMap := make(map[structs.ServiceName]struct{}) for _, svc := range services.Services { // Make sure to add every service to this map, we use it to cancel watches below. svcMap[svc.Service] = struct{}{} @@ -935,7 +935,7 @@ func (s *state) handleUpdateTerminatingGateway(u cache.UpdateEvent, snap *Config err := s.cache.Notify(ctx, cachetype.HealthServicesName, &structs.ServiceSpecificRequest{ Datacenter: s.source.Datacenter, QueryOptions: structs.QueryOptions{Token: s.token}, - ServiceName: svc.Service.ID, + ServiceName: svc.Service.Name, EnterpriseMeta: svc.Service.EnterpriseMeta, // The gateway acts as the service's proxy, so we do NOT want to discover other proxies @@ -965,7 +965,7 @@ func (s *state) handleUpdateTerminatingGateway(u cache.UpdateEvent, snap *Config Entries: []structs.IntentionMatchEntry{ { Namespace: svc.Service.NamespaceOrDefault(), - Name: svc.Service.ID, + Name: svc.Service.Name, }, }, }, @@ -989,7 +989,7 @@ func (s *state) handleUpdateTerminatingGateway(u cache.UpdateEvent, snap *Config err := s.cache.Notify(ctx, cachetype.ConnectCALeafName, &cachetype.ConnectCALeafRequest{ Datacenter: s.source.Datacenter, Token: s.token, - Service: svc.Service.ID, + Service: svc.Service.Name, EnterpriseMeta: svc.Service.EnterpriseMeta, }, serviceLeafIDPrefix+svc.Service.String(), s.ch) @@ -1012,7 +1012,7 @@ func (s *state) handleUpdateTerminatingGateway(u cache.UpdateEvent, snap *Config Datacenter: s.source.Datacenter, QueryOptions: structs.QueryOptions{Token: s.token}, Kind: structs.ServiceResolver, - Name: svc.Service.ID, + Name: svc.Service.Name, EnterpriseMeta: svc.Service.EnterpriseMeta, }, serviceResolverIDPrefix+svc.Service.String(), s.ch) @@ -1029,54 +1029,54 @@ func (s *state) handleUpdateTerminatingGateway(u cache.UpdateEvent, snap *Config } // Delete gateway service mapping for services that were not in the update - for sid, _ := range snap.TerminatingGateway.GatewayServices { - if _, ok := svcMap[sid]; !ok { - delete(snap.TerminatingGateway.GatewayServices, sid) + for sn, _ := range snap.TerminatingGateway.GatewayServices { + if _, ok := svcMap[sn]; !ok { + delete(snap.TerminatingGateway.GatewayServices, sn) } } // Clean up services with hostname mapping for services that were not in the update - for sid, _ := range snap.TerminatingGateway.HostnameServices { - if _, ok := svcMap[sid]; !ok { - delete(snap.TerminatingGateway.HostnameServices, sid) + for sn, _ := range snap.TerminatingGateway.HostnameServices { + if _, ok := svcMap[sn]; !ok { + delete(snap.TerminatingGateway.HostnameServices, sn) } } // Cancel service instance watches for services that were not in the update - for sid, cancelFn := range snap.TerminatingGateway.WatchedServices { - if _, ok := svcMap[sid]; !ok { - logger.Debug("canceling watch for service", "service", sid.String()) - delete(snap.TerminatingGateway.WatchedServices, sid) - delete(snap.TerminatingGateway.ServiceGroups, sid) + for sn, cancelFn := range snap.TerminatingGateway.WatchedServices { + if _, ok := svcMap[sn]; !ok { + logger.Debug("canceling watch for service", "service", sn.String()) + delete(snap.TerminatingGateway.WatchedServices, sn) + delete(snap.TerminatingGateway.ServiceGroups, sn) cancelFn() } } // Cancel leaf cert watches for services that were not in the update - for sid, cancelFn := range snap.TerminatingGateway.WatchedLeaves { - if _, ok := svcMap[sid]; !ok { - logger.Debug("canceling watch for leaf cert", "service", sid.String()) - delete(snap.TerminatingGateway.WatchedLeaves, sid) - delete(snap.TerminatingGateway.ServiceLeaves, sid) + for sn, cancelFn := range snap.TerminatingGateway.WatchedLeaves { + if _, ok := svcMap[sn]; !ok { + logger.Debug("canceling watch for leaf cert", "service", sn.String()) + delete(snap.TerminatingGateway.WatchedLeaves, sn) + delete(snap.TerminatingGateway.ServiceLeaves, sn) cancelFn() } } // Cancel service-resolver watches for services that were not in the update - for sid, cancelFn := range snap.TerminatingGateway.WatchedResolvers { - if _, ok := svcMap[sid]; !ok { - logger.Debug("canceling watch for service-resolver", "service", sid.String()) - delete(snap.TerminatingGateway.WatchedResolvers, sid) - delete(snap.TerminatingGateway.ServiceResolvers, sid) + for sn, cancelFn := range snap.TerminatingGateway.WatchedResolvers { + if _, ok := svcMap[sn]; !ok { + logger.Debug("canceling watch for service-resolver", "service", sn.String()) + delete(snap.TerminatingGateway.WatchedResolvers, sn) + delete(snap.TerminatingGateway.ServiceResolvers, sn) cancelFn() } } // Cancel intention watches for services that were not in the update - for sid, cancelFn := range snap.TerminatingGateway.WatchedIntentions { - if _, ok := svcMap[sid]; !ok { - logger.Debug("canceling watch for intention", "service", sid.String()) - delete(snap.TerminatingGateway.WatchedIntentions, sid) + for sn, cancelFn := range snap.TerminatingGateway.WatchedIntentions { + if _, ok := svcMap[sn]; !ok { + logger.Debug("canceling watch for intention", "service", sn.String()) + delete(snap.TerminatingGateway.WatchedIntentions, sn) // No additional deletions needed, since intentions aren't stored in snapshot @@ -1090,13 +1090,13 @@ func (s *state) handleUpdateTerminatingGateway(u cache.UpdateEvent, snap *Config return fmt.Errorf("invalid type for response: %T", u.Result) } - sid := structs.ServiceIDFromString(strings.TrimPrefix(u.CorrelationID, externalServiceIDPrefix)) - delete(snap.TerminatingGateway.ServiceGroups, sid) - delete(snap.TerminatingGateway.HostnameServices, sid) + sn := structs.ServiceNameFromString(strings.TrimPrefix(u.CorrelationID, externalServiceIDPrefix)) + delete(snap.TerminatingGateway.ServiceGroups, sn) + delete(snap.TerminatingGateway.HostnameServices, sn) if len(resp.Nodes) > 0 { - snap.TerminatingGateway.ServiceGroups[sid] = resp.Nodes - snap.TerminatingGateway.HostnameServices[sid] = s.hostnameEndpoints(logging.TerminatingGateway, snap.Datacenter, resp.Nodes) + snap.TerminatingGateway.ServiceGroups[sn] = resp.Nodes + snap.TerminatingGateway.HostnameServices[sn] = s.hostnameEndpoints(logging.TerminatingGateway, snap.Datacenter, resp.Nodes) } // Store leaf cert for watched service @@ -1106,8 +1106,8 @@ func (s *state) handleUpdateTerminatingGateway(u cache.UpdateEvent, snap *Config return fmt.Errorf("invalid type for response: %T", u.Result) } - sid := structs.ServiceIDFromString(strings.TrimPrefix(u.CorrelationID, serviceLeafIDPrefix)) - snap.TerminatingGateway.ServiceLeaves[sid] = leaf + sn := structs.ServiceNameFromString(strings.TrimPrefix(u.CorrelationID, serviceLeafIDPrefix)) + snap.TerminatingGateway.ServiceLeaves[sn] = leaf case strings.HasPrefix(u.CorrelationID, "service-resolver:"): configEntries, ok := u.Result.(*structs.IndexedConfigEntries) @@ -1117,7 +1117,7 @@ func (s *state) handleUpdateTerminatingGateway(u cache.UpdateEvent, snap *Config // There should only ever be one entry for a service resolver within a namespace if len(configEntries.Entries) == 1 { if resolver, ok := configEntries.Entries[0].(*structs.ServiceResolverConfigEntry); ok { - snap.TerminatingGateway.ServiceResolvers[structs.NewServiceID(resolver.Name, &resolver.EnterpriseMeta)] = resolver + snap.TerminatingGateway.ServiceResolvers[structs.NewServiceName(resolver.Name, &resolver.EnterpriseMeta)] = resolver } } @@ -1169,32 +1169,31 @@ func (s *state) handleUpdateMeshGateway(u cache.UpdateEvent, snap *ConfigSnapsho return fmt.Errorf("invalid type for response: %T", u.Result) } - svcMap := make(map[structs.ServiceID]struct{}) + svcMap := make(map[structs.ServiceName]struct{}) for _, svc := range services.Services { - sid := svc.ToServiceID() // Make sure to add every service to this map, we use it to cancel // watches below. - svcMap[sid] = struct{}{} + svcMap[svc] = struct{}{} - if _, ok := snap.MeshGateway.WatchedServices[sid]; !ok { + if _, ok := snap.MeshGateway.WatchedServices[svc]; !ok { ctx, cancel := context.WithCancel(s.ctx) err := s.cache.Notify(ctx, cachetype.HealthServicesName, &structs.ServiceSpecificRequest{ Datacenter: s.source.Datacenter, QueryOptions: structs.QueryOptions{Token: s.token}, ServiceName: svc.Name, Connect: true, - EnterpriseMeta: sid.EnterpriseMeta, - }, fmt.Sprintf("connect-service:%s", sid.String()), s.ch) + EnterpriseMeta: svc.EnterpriseMeta, + }, fmt.Sprintf("connect-service:%s", svc.String()), s.ch) if err != nil { meshLogger.Error("failed to register watch for connect-service", - "service", sid.String(), + "service", svc.String(), "error", err, ) cancel() return err } - snap.MeshGateway.WatchedServices[sid] = cancel + snap.MeshGateway.WatchedServices[svc] = cancel } } @@ -1269,10 +1268,10 @@ func (s *state) handleUpdateMeshGateway(u cache.UpdateEvent, snap *ConfigSnapsho return fmt.Errorf("invalid type for response: %T", u.Result) } - resolvers := make(map[structs.ServiceID]*structs.ServiceResolverConfigEntry) + resolvers := make(map[structs.ServiceName]*structs.ServiceResolverConfigEntry) for _, entry := range configEntries.Entries { if resolver, ok := entry.(*structs.ServiceResolverConfigEntry); ok { - resolvers[structs.NewServiceID(resolver.Name, &resolver.EnterpriseMeta)] = resolver + resolvers[structs.NewServiceName(resolver.Name, &resolver.EnterpriseMeta)] = resolver } } snap.MeshGateway.ServiceResolvers = resolvers @@ -1305,12 +1304,12 @@ func (s *state) handleUpdateMeshGateway(u cache.UpdateEvent, snap *ConfigSnapsho return fmt.Errorf("invalid type for response: %T", u.Result) } - sid := structs.ServiceIDFromString(strings.TrimPrefix(u.CorrelationID, "connect-service:")) + sn := structs.ServiceNameFromString(strings.TrimPrefix(u.CorrelationID, "connect-service:")) if len(resp.Nodes) > 0 { - snap.MeshGateway.ServiceGroups[sid] = resp.Nodes - } else if _, ok := snap.MeshGateway.ServiceGroups[sid]; ok { - delete(snap.MeshGateway.ServiceGroups, sid) + snap.MeshGateway.ServiceGroups[sn] = resp.Nodes + } else if _, ok := snap.MeshGateway.ServiceGroups[sn]; ok { + delete(snap.MeshGateway.ServiceGroups, sn) } case strings.HasPrefix(u.CorrelationID, "mesh-gateway:"): resp, ok := u.Result.(*structs.IndexedCheckServiceNodes) @@ -1412,7 +1411,7 @@ func (s *state) handleUpdateIngressGateway(u cache.UpdateEvent, snap *ConfigSnap func makeUpstream(g *structs.GatewayService) structs.Upstream { upstream := structs.Upstream{ - DestinationName: g.Service.ID, + DestinationName: g.Service.Name, DestinationNamespace: g.Service.NamespaceOrDefault(), LocalBindPort: g.Port, IngressHosts: g.Hosts, @@ -1565,11 +1564,11 @@ func (s *state) hostnameEndpoints(loggerName string, localDC string, nodes struc if hasHostname && hasIP { dc := nodes[0].Node.Datacenter - sid := nodes[0].Service.CompoundServiceName() + sn := nodes[0].Service.CompoundServiceName() s.logger.Named(loggerName). Warn("service contains instances with mix of hostnames and IP addresses; only hostnames will be passed to Envoy", - "dc", dc, "service", sid.String()) + "dc", dc, "service", sn.String()) } return resp } diff --git a/agent/proxycfg/state_test.go b/agent/proxycfg/state_test.go index 9067a6f696..6006da26db 100644 --- a/agent/proxycfg/state_test.go +++ b/agent/proxycfg/state_test.go @@ -596,10 +596,10 @@ func TestState_WatchesAndUpdates(t *testing.T) { } // Used in terminating-gateway cases to account for differences in OSS/ent implementations of ServiceID.String() - db := structs.NewServiceID("db", nil) + db := structs.NewServiceName("db", nil) dbStr := db.String() - api := structs.NewServiceID("api", nil) + api := structs.NewServiceName("api", nil) apiStr := api.String() cases := map[string]testCase{ @@ -855,8 +855,8 @@ func TestState_WatchesAndUpdates(t *testing.T) { Result: &structs.IndexedGatewayServices{ Services: structs.GatewayServices{ { - Gateway: structs.NewServiceID("ingress-gateway", nil), - Service: structs.NewServiceID("api", nil), + Gateway: structs.NewServiceName("ingress-gateway", nil), + Service: structs.NewServiceName("api", nil), Port: 9999, Protocol: "http", }, @@ -994,8 +994,8 @@ func TestState_WatchesAndUpdates(t *testing.T) { Result: &structs.IndexedGatewayServices{ Services: structs.GatewayServices{ { - Gateway: structs.NewServiceID("ingress-gateway", nil), - Service: structs.NewServiceID("api", nil), + Gateway: structs.NewServiceName("ingress-gateway", nil), + Service: structs.NewServiceName("api", nil), Hosts: []string{"test.example.com"}, Port: 9999, }, @@ -1105,8 +1105,8 @@ func TestState_WatchesAndUpdates(t *testing.T) { Result: &structs.IndexedGatewayServices{ Services: structs.GatewayServices{ { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("terminating-gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("terminating-gateway", nil), }, }, }, @@ -1125,16 +1125,16 @@ func TestState_WatchesAndUpdates(t *testing.T) { Result: &structs.IndexedGatewayServices{ Services: structs.GatewayServices{ { - Service: structs.NewServiceID("db", nil), - Gateway: structs.NewServiceID("terminating-gateway", nil), + Service: structs.NewServiceName("db", nil), + Gateway: structs.NewServiceName("terminating-gateway", nil), }, { - Service: structs.NewServiceID("billing", nil), - Gateway: structs.NewServiceID("terminating-gateway", nil), + Service: structs.NewServiceName("billing", nil), + Gateway: structs.NewServiceName("terminating-gateway", nil), }, { - Service: structs.NewServiceID("api", nil), - Gateway: structs.NewServiceID("terminating-gateway", nil), + Service: structs.NewServiceName("api", nil), + Gateway: structs.NewServiceName("terminating-gateway", nil), }, }, }, @@ -1142,9 +1142,9 @@ func TestState_WatchesAndUpdates(t *testing.T) { }, }, verifySnapshot: func(t testing.TB, snap *ConfigSnapshot) { - db := structs.NewServiceID("db", nil) - billing := structs.NewServiceID("billing", nil) - api := structs.NewServiceID("api", nil) + db := structs.NewServiceName("db", nil) + billing := structs.NewServiceName("billing", nil) + api := structs.NewServiceName("api", nil) require.True(t, snap.Valid(), "gateway with service list is valid") require.Len(t, snap.TerminatingGateway.WatchedServices, 3) @@ -1199,7 +1199,7 @@ func TestState_WatchesAndUpdates(t *testing.T) { }, verifySnapshot: func(t testing.TB, snap *ConfigSnapshot) { require.Len(t, snap.TerminatingGateway.ServiceGroups, 1) - require.Equal(t, snap.TerminatingGateway.ServiceGroups[structs.NewServiceID("db", nil)], + require.Equal(t, snap.TerminatingGateway.ServiceGroups[structs.NewServiceName("db", nil)], structs.CheckServiceNodes{ { Node: &structs.Node{ @@ -1299,11 +1299,11 @@ func TestState_WatchesAndUpdates(t *testing.T) { }, }, } - sid := structs.NewServiceID("api", nil) - require.Equal(t, snap.TerminatingGateway.ServiceGroups[sid], expect) + sn := structs.NewServiceName("api", nil) + require.Equal(t, snap.TerminatingGateway.ServiceGroups[sn], expect) // The instance in node3 should not be present in HostnameDatacenters because it has a valid IP - require.ElementsMatch(t, snap.TerminatingGateway.HostnameServices[sid], expect[:2]) + require.ElementsMatch(t, snap.TerminatingGateway.HostnameServices[sn], expect[:2]) }, }, verificationStage{ @@ -1318,7 +1318,7 @@ func TestState_WatchesAndUpdates(t *testing.T) { }, }, verifySnapshot: func(t testing.TB, snap *ConfigSnapshot) { - require.Equal(t, snap.TerminatingGateway.ServiceLeaves[structs.NewServiceID("db", nil)], issuedCert) + require.Equal(t, snap.TerminatingGateway.ServiceLeaves[structs.NewServiceName("db", nil)], issuedCert) }, }, verificationStage{ @@ -1353,7 +1353,7 @@ func TestState_WatchesAndUpdates(t *testing.T) { Datacenter: "dc2", }, } - require.Equal(t, want, snap.TerminatingGateway.ServiceResolvers[structs.NewServiceID("db", nil)]) + require.Equal(t, want, snap.TerminatingGateway.ServiceResolvers[structs.NewServiceName("db", nil)]) }, }, verificationStage{ @@ -1363,8 +1363,8 @@ func TestState_WatchesAndUpdates(t *testing.T) { Result: &structs.IndexedGatewayServices{ Services: structs.GatewayServices{ { - Service: structs.NewServiceID("billing", nil), - Gateway: structs.NewServiceID("terminating-gateway", nil), + Service: structs.NewServiceName("billing", nil), + Gateway: structs.NewServiceName("terminating-gateway", nil), }, }, }, @@ -1372,7 +1372,7 @@ func TestState_WatchesAndUpdates(t *testing.T) { }, }, verifySnapshot: func(t testing.TB, snap *ConfigSnapshot) { - billing := structs.NewServiceID("billing", nil) + billing := structs.NewServiceName("billing", nil) require.True(t, snap.Valid(), "gateway with service list is valid") diff --git a/agent/proxycfg/testing.go b/agent/proxycfg/testing.go index 8dfc6a7463..dc453e988d 100644 --- a/agent/proxycfg/testing.go +++ b/agent/proxycfg/testing.go @@ -1373,17 +1373,17 @@ func testConfigSnapshotMeshGateway(t testing.T, populateServices bool, useFedera if populateServices { snap.MeshGateway = configSnapshotMeshGateway{ - WatchedServices: map[structs.ServiceID]context.CancelFunc{ - structs.NewServiceID("foo", nil): nil, - structs.NewServiceID("bar", nil): nil, + WatchedServices: map[structs.ServiceName]context.CancelFunc{ + structs.NewServiceName("foo", nil): nil, + structs.NewServiceName("bar", nil): nil, }, WatchedServicesSet: true, WatchedDatacenters: map[string]context.CancelFunc{ "dc2": nil, }, - ServiceGroups: map[structs.ServiceID]structs.CheckServiceNodes{ - structs.NewServiceID("foo", nil): TestGatewayServiceGroupFooDC1(t), - structs.NewServiceID("bar", nil): TestGatewayServiceGroupBarDC1(t), + ServiceGroups: map[structs.ServiceName]structs.CheckServiceNodes{ + structs.NewServiceName("foo", nil): TestGatewayServiceGroupFooDC1(t), + structs.NewServiceName("bar", nil): TestGatewayServiceGroupBarDC1(t), }, GatewayGroups: map[string]structs.CheckServiceNodes{ "dc2": TestGatewayNodesDC2(t), @@ -1607,7 +1607,7 @@ func testConfigSnapshotTerminatingGateway(t testing.T, populateServices bool) *C Datacenter: "dc1", } if populateServices { - web := structs.NewServiceID("web", nil) + web := structs.NewServiceName("web", nil) webNodes := TestUpstreamNodes(t) webNodes[0].Service.Meta = map[string]string{ "version": "1", @@ -1616,7 +1616,7 @@ func testConfigSnapshotTerminatingGateway(t testing.T, populateServices bool) *C "version": "2", } - api := structs.NewServiceID("api", nil) + api := structs.NewServiceName("api", nil) apiNodes := structs.CheckServiceNodes{ structs.CheckServiceNode{ Node: &structs.Node{ @@ -1673,11 +1673,11 @@ func testConfigSnapshotTerminatingGateway(t testing.T, populateServices bool) *C } snap.TerminatingGateway = configSnapshotTerminatingGateway{ - ServiceGroups: map[structs.ServiceID]structs.CheckServiceNodes{ + ServiceGroups: map[structs.ServiceName]structs.CheckServiceNodes{ web: webNodes, api: apiNodes, }, - GatewayServices: map[structs.ServiceID]structs.GatewayService{ + GatewayServices: map[structs.ServiceName]structs.GatewayService{ web: { Service: web, CAFile: "ca.cert.pem", @@ -1689,16 +1689,16 @@ func testConfigSnapshotTerminatingGateway(t testing.T, populateServices bool) *C KeyFile: "api.key.pem", }, }, - HostnameServices: map[structs.ServiceID]structs.CheckServiceNodes{ + HostnameServices: map[structs.ServiceName]structs.CheckServiceNodes{ api: {apiNodes[0], apiNodes[1]}, }, } - snap.TerminatingGateway.ServiceLeaves = map[structs.ServiceID]*structs.IssuedCert{ - structs.NewServiceID("web", nil): { + snap.TerminatingGateway.ServiceLeaves = map[structs.ServiceName]*structs.IssuedCert{ + structs.NewServiceName("web", nil): { CertPEM: golden(t, "test-leaf-cert"), PrivateKeyPEM: golden(t, "test-leaf-key"), }, - structs.NewServiceID("api", nil): { + structs.NewServiceName("api", nil): { CertPEM: golden(t, "alt-test-leaf-cert"), PrivateKeyPEM: golden(t, "alt-test-leaf-key"), }, diff --git a/agent/structs/config_entry_gateways.go b/agent/structs/config_entry_gateways.go index d7eb97a73a..97140c6b07 100644 --- a/agent/structs/config_entry_gateways.go +++ b/agent/structs/config_entry_gateways.go @@ -231,8 +231,8 @@ func (e *IngressGatewayConfigEntry) GetEnterpriseMeta() *EnterpriseMeta { return &e.EnterpriseMeta } -func (s *IngressService) ToServiceID() ServiceID { - return NewServiceID(s.Name, &s.EnterpriseMeta) +func (s *IngressService) ToServiceName() ServiceName { + return NewServiceName(s.Name, &s.EnterpriseMeta) } // TerminatingGatewayConfigEntry manages the configuration for a terminating service @@ -360,17 +360,17 @@ func (e *TerminatingGatewayConfigEntry) GetEnterpriseMeta() *EnterpriseMeta { // GatewayService is used to associate gateways with their linked services. type GatewayService struct { - Gateway ServiceID - Service ServiceID + Gateway ServiceName + Service ServiceName GatewayKind ServiceKind - Port int - Protocol string - Hosts []string - CAFile string - CertFile string - KeyFile string - SNI string - FromWildcard bool + Port int `json:",omitempty"` + Protocol string `json:",omitempty"` + Hosts []string `json:",omitempty"` + CAFile string `json:",omitempty"` + CertFile string `json:",omitempty"` + KeyFile string `json:",omitempty"` + SNI string `json:",omitempty"` + FromWildcard bool `json:",omitempty"` RaftIndex } diff --git a/agent/structs/structs.go b/agent/structs/structs.go index 8142b024b0..6bdfe49cae 100644 --- a/agent/structs/structs.go +++ b/agent/structs/structs.go @@ -840,12 +840,10 @@ func (s *ServiceNode) ToNodeService() *NodeService { } } -func (sn *ServiceNode) compoundID(preferName bool) ServiceID { - var id string - if sn.ServiceID == "" || (preferName && sn.ServiceName != "") { +func (sn *ServiceNode) CompoundServiceID() ServiceID { + id := sn.ServiceID + if id == "" { id = sn.ServiceName - } else { - id = sn.ServiceID } // copy the ent meta and normalize it @@ -858,12 +856,20 @@ func (sn *ServiceNode) compoundID(preferName bool) ServiceID { } } -func (sn *ServiceNode) CompoundServiceID() ServiceID { - return sn.compoundID(false) -} +func (sn *ServiceNode) CompoundServiceName() ServiceName { + name := sn.ServiceName + if name == "" { + name = sn.ServiceID + } -func (sn *ServiceNode) CompoundServiceName() ServiceID { - return sn.compoundID(true) + // copy the ent meta and normalize it + entMeta := sn.EnterpriseMeta + entMeta.Normalize() + + return ServiceName{ + Name: name, + EnterpriseMeta: entMeta, + } } // Weights represent the weight used by DNS for a given status @@ -1000,11 +1006,35 @@ func (ns *NodeService) compoundID(preferName bool) ServiceID { } func (ns *NodeService) CompoundServiceID() ServiceID { - return ns.compoundID(false) + id := ns.ID + if id == "" { + id = ns.Service + } + + // copy the ent meta and normalize it + entMeta := ns.EnterpriseMeta + entMeta.Normalize() + + return ServiceID{ + ID: id, + EnterpriseMeta: entMeta, + } } -func (ns *NodeService) CompoundServiceName() ServiceID { - return ns.compoundID(true) +func (ns *NodeService) CompoundServiceName() ServiceName { + name := ns.Service + if name == "" { + name = ns.ID + } + + // copy the ent meta and normalize it + entMeta := ns.EnterpriseMeta + entMeta.Normalize() + + return ServiceName{ + Name: name, + EnterpriseMeta: entMeta, + } } // ServiceConnect are the shared Connect settings between all service @@ -1727,6 +1757,30 @@ type ServiceName struct { EnterpriseMeta } +func NewServiceName(name string, entMeta *EnterpriseMeta) ServiceName { + var ret ServiceName + ret.Name = name + if entMeta == nil { + entMeta = DefaultEnterpriseMeta() + } + + ret.EnterpriseMeta = *entMeta + ret.EnterpriseMeta.Normalize() + return ret +} + +func (n *ServiceName) Matches(o *ServiceName) bool { + if n == nil && o == nil { + return true + } + + if n == nil || o == nil || n.Name != o.Name || !n.EnterpriseMeta.Matches(&o.EnterpriseMeta) { + return false + } + + return true +} + func (si *ServiceName) ToServiceID() ServiceID { return ServiceID{ID: si.Name, EnterpriseMeta: si.EnterpriseMeta} } diff --git a/agent/structs/structs_oss.go b/agent/structs/structs_oss.go index 0cad0f3cfb..742925180b 100644 --- a/agent/structs/structs_oss.go +++ b/agent/structs/structs_oss.go @@ -106,6 +106,19 @@ func ServiceIDFromString(input string) ServiceID { return ServiceID{ID: id} } +func ParseServiceNameString(input string) (string, *EnterpriseMeta) { + return input, DefaultEnterpriseMeta() +} + +func (n *ServiceName) String() string { + return n.Name +} + +func ServiceNameFromString(input string) ServiceName { + id, _ := ParseServiceNameString(input) + return ServiceName{Name: id} +} + func (cid *CheckID) String() string { return string(cid.ID) } diff --git a/agent/structs/structs_test.go b/agent/structs/structs_test.go index 5b5907d8b6..0ba448a24f 100644 --- a/agent/structs/structs_test.go +++ b/agent/structs/structs_test.go @@ -2124,8 +2124,8 @@ func TestSnapshotRequestResponse_MsgpackEncodeDecode(t *testing.T) { } func TestGatewayService_IsSame(t *testing.T) { - gateway := NewServiceID("gateway", nil) - svc := NewServiceID("web", nil) + gateway := NewServiceName("gateway", nil) + svc := NewServiceName("web", nil) kind := ServiceKindTerminatingGateway ca := "ca.pem" cert := "client.pem" @@ -2169,8 +2169,8 @@ func TestGatewayService_IsSame(t *testing.T) { t.Fatalf("should be the same") } } - check(func() { other.Gateway = NewServiceID("other", nil) }, func() { other.Gateway = gateway }) - check(func() { other.Service = NewServiceID("other", nil) }, func() { other.Service = svc }) + check(func() { other.Gateway = NewServiceName("other", nil) }, func() { other.Gateway = gateway }) + check(func() { other.Service = NewServiceName("other", nil) }, func() { other.Service = svc }) check(func() { other.GatewayKind = ServiceKindIngressGateway }, func() { other.GatewayKind = kind }) check(func() { other.CAFile = "/certs/cert.pem" }, func() { other.CAFile = ca }) check(func() { other.CertFile = "/certs/cert.pem" }, func() { other.CertFile = cert }) diff --git a/agent/ui_endpoint.go b/agent/ui_endpoint.go index 4fef9e44aa..36297675bc 100644 --- a/agent/ui_endpoint.go +++ b/agent/ui_endpoint.go @@ -220,7 +220,7 @@ func summarizeServices(dump structs.ServiceDump) []*ServiceSummary { for _, csn := range dump { if csn.GatewayService != nil { - sum := getService(csn.GatewayService.Service) + sum := getService(csn.GatewayService.Service.ToServiceID()) sum.GatewayConfig.ListenerPort = csn.GatewayService.Port } diff --git a/agent/xds/clusters.go b/agent/xds/clusters.go index c081a7bdf3..052e0349ae 100644 --- a/agent/xds/clusters.go +++ b/agent/xds/clusters.go @@ -184,8 +184,8 @@ func (s *Server) clustersFromSnapshotMeshGateway(cfgSnap *proxycfg.ConfigSnapsho } func (s *Server) makeGatewayServiceClusters(cfgSnap *proxycfg.ConfigSnapshot) ([]proto.Message, error) { - var services map[structs.ServiceID]structs.CheckServiceNodes - var resolvers map[structs.ServiceID]*structs.ServiceResolverConfigEntry + var services map[structs.ServiceName]structs.CheckServiceNodes + var resolvers map[structs.ServiceName]*structs.ServiceResolverConfigEntry var hostnameEndpoints structs.CheckServiceNodes switch cfgSnap.Kind { @@ -202,7 +202,7 @@ func (s *Server) makeGatewayServiceClusters(cfgSnap *proxycfg.ConfigSnapshot) ([ clusters := make([]proto.Message, 0, len(services)) for svc, _ := range services { - clusterName := connect.ServiceSNI(svc.ID, "", svc.NamespaceOrDefault(), cfgSnap.Datacenter, cfgSnap.Roots.TrustDomain) + clusterName := connect.ServiceSNI(svc.Name, "", svc.NamespaceOrDefault(), cfgSnap.Datacenter, cfgSnap.Roots.TrustDomain) resolver, hasResolver := resolvers[svc] if !hasResolver { @@ -236,7 +236,7 @@ func (s *Server) makeGatewayServiceClusters(cfgSnap *proxycfg.ConfigSnapshot) ([ } opts := gatewayClusterOpts{ - name: connect.ServiceSNI(svc.ID, name, svc.NamespaceOrDefault(), cfgSnap.Datacenter, cfgSnap.Roots.TrustDomain), + name: connect.ServiceSNI(svc.Name, name, svc.NamespaceOrDefault(), cfgSnap.Datacenter, cfgSnap.Roots.TrustDomain), hostnameEndpoints: subsetHostnameEndpoints, onlyPassing: subset.OnlyPassing, connectTimeout: resolver.ConnectTimeout, @@ -691,7 +691,7 @@ func (s *Server) makeGatewayCluster(snap *proxycfg.ConfigSnapshot, opts gatewayC } // injectTerminatingGatewayTLSContext adds an UpstreamTlsContext to a cluster for TLS origination -func injectTerminatingGatewayTLSContext(cfgSnap *proxycfg.ConfigSnapshot, cluster *envoy.Cluster, service structs.ServiceID) { +func injectTerminatingGatewayTLSContext(cfgSnap *proxycfg.ConfigSnapshot, cluster *envoy.Cluster, service structs.ServiceName) { if mapping, ok := cfgSnap.TerminatingGateway.GatewayServices[service]; ok && mapping.CAFile != "" { cluster.TlsContext = &envoyauth.UpstreamTlsContext{ CommonTlsContext: makeCommonTLSContextFromFiles(mapping.CAFile, mapping.CertFile, mapping.KeyFile), diff --git a/agent/xds/clusters_test.go b/agent/xds/clusters_test.go index 53c5b4bccd..43de5e2433 100644 --- a/agent/xds/clusters_test.go +++ b/agent/xds/clusters_test.go @@ -268,8 +268,8 @@ func TestClustersFromSnapshot(t *testing.T) { name: "mesh-gateway-service-subsets", create: proxycfg.TestConfigSnapshotMeshGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.MeshGateway.ServiceResolvers = map[structs.ServiceID]*structs.ServiceResolverConfigEntry{ - structs.NewServiceID("bar", nil): &structs.ServiceResolverConfigEntry{ + snap.MeshGateway.ServiceResolvers = map[structs.ServiceName]*structs.ServiceResolverConfigEntry{ + structs.NewServiceName("bar", nil): &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "bar", Subsets: map[string]structs.ServiceResolverSubset{ @@ -289,8 +289,8 @@ func TestClustersFromSnapshot(t *testing.T) { name: "mesh-gateway-ignore-extra-resolvers", create: proxycfg.TestConfigSnapshotMeshGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.MeshGateway.ServiceResolvers = map[structs.ServiceID]*structs.ServiceResolverConfigEntry{ - structs.NewServiceID("bar", nil): &structs.ServiceResolverConfigEntry{ + snap.MeshGateway.ServiceResolvers = map[structs.ServiceName]*structs.ServiceResolverConfigEntry{ + structs.NewServiceName("bar", nil): &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "bar", DefaultSubset: "v2", @@ -304,7 +304,7 @@ func TestClustersFromSnapshot(t *testing.T) { }, }, }, - structs.NewServiceID("notfound", nil): &structs.ServiceResolverConfigEntry{ + structs.NewServiceName("notfound", nil): &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "notfound", DefaultSubset: "v2", @@ -325,8 +325,8 @@ func TestClustersFromSnapshot(t *testing.T) { name: "mesh-gateway-service-timeouts", create: proxycfg.TestConfigSnapshotMeshGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.MeshGateway.ServiceResolvers = map[structs.ServiceID]*structs.ServiceResolverConfigEntry{ - structs.NewServiceID("bar", nil): &structs.ServiceResolverConfigEntry{ + snap.MeshGateway.ServiceResolvers = map[structs.ServiceName]*structs.ServiceResolverConfigEntry{ + structs.NewServiceName("bar", nil): &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "bar", ConnectTimeout: 10 * time.Second, @@ -432,8 +432,8 @@ func TestClustersFromSnapshot(t *testing.T) { name: "terminating-gateway-service-subsets", create: proxycfg.TestConfigSnapshotTerminatingGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceID]*structs.ServiceResolverConfigEntry{ - structs.NewServiceID("web", nil): { + snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceName]*structs.ServiceResolverConfigEntry{ + structs.NewServiceName("web", nil): { Kind: structs.ServiceResolver, Name: "web", Subsets: map[string]structs.ServiceResolverSubset{ @@ -453,8 +453,8 @@ func TestClustersFromSnapshot(t *testing.T) { name: "terminating-gateway-hostname-service-subsets", create: proxycfg.TestConfigSnapshotTerminatingGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceID]*structs.ServiceResolverConfigEntry{ - structs.NewServiceID("api", nil): { + snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceName]*structs.ServiceResolverConfigEntry{ + structs.NewServiceName("api", nil): { Kind: structs.ServiceResolver, Name: "api", Subsets: map[string]structs.ServiceResolverSubset{ @@ -470,8 +470,8 @@ func TestClustersFromSnapshot(t *testing.T) { name: "terminating-gateway-ignore-extra-resolvers", create: proxycfg.TestConfigSnapshotTerminatingGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceID]*structs.ServiceResolverConfigEntry{ - structs.NewServiceID("web", nil): { + snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceName]*structs.ServiceResolverConfigEntry{ + structs.NewServiceName("web", nil): { Kind: structs.ServiceResolver, Name: "web", DefaultSubset: "v2", @@ -485,7 +485,7 @@ func TestClustersFromSnapshot(t *testing.T) { }, }, }, - structs.NewServiceID("notfound", nil): { + structs.NewServiceName("notfound", nil): { Kind: structs.ServiceResolver, Name: "notfound", DefaultSubset: "v2", diff --git a/agent/xds/endpoints.go b/agent/xds/endpoints.go index ea39f83a85..68b20a3638 100644 --- a/agent/xds/endpoints.go +++ b/agent/xds/endpoints.go @@ -211,8 +211,8 @@ func (s *Server) endpointsFromSnapshotMeshGateway(cfgSnap *proxycfg.ConfigSnapsh func (s *Server) endpointsFromServicesAndResolvers( cfgSnap *proxycfg.ConfigSnapshot, - services map[structs.ServiceID]structs.CheckServiceNodes, - resolvers map[structs.ServiceID]*structs.ServiceResolverConfigEntry) ([]proto.Message, error) { + services map[structs.ServiceName]structs.CheckServiceNodes, + resolvers map[structs.ServiceName]*structs.ServiceResolverConfigEntry) ([]proto.Message, error) { resources := make([]proto.Message, 0, len(services)) @@ -249,7 +249,7 @@ func (s *Server) endpointsFromServicesAndResolvers( // now generate the load assignment for all subsets for subsetName, groups := range clusterEndpoints { - clusterName := connect.ServiceSNI(svc.ID, subsetName, svc.NamespaceOrDefault(), cfgSnap.Datacenter, cfgSnap.Roots.TrustDomain) + clusterName := connect.ServiceSNI(svc.Name, subsetName, svc.NamespaceOrDefault(), cfgSnap.Datacenter, cfgSnap.Roots.TrustDomain) la := makeLoadAssignment( clusterName, groups, diff --git a/agent/xds/endpoints_test.go b/agent/xds/endpoints_test.go index 586d943103..bbcca387cd 100644 --- a/agent/xds/endpoints_test.go +++ b/agent/xds/endpoints_test.go @@ -326,8 +326,8 @@ func Test_endpointsFromSnapshot(t *testing.T) { name: "mesh-gateway-service-subsets", create: proxycfg.TestConfigSnapshotMeshGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.MeshGateway.ServiceResolvers = map[structs.ServiceID]*structs.ServiceResolverConfigEntry{ - structs.NewServiceID("bar", nil): &structs.ServiceResolverConfigEntry{ + snap.MeshGateway.ServiceResolvers = map[structs.ServiceName]*structs.ServiceResolverConfigEntry{ + structs.NewServiceName("bar", nil): &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "bar", Subsets: map[string]structs.ServiceResolverSubset{ @@ -340,7 +340,7 @@ func Test_endpointsFromSnapshot(t *testing.T) { }, }, }, - structs.NewServiceID("foo", nil): &structs.ServiceResolverConfigEntry{ + structs.NewServiceName("foo", nil): &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "foo", Subsets: map[string]structs.ServiceResolverSubset{ @@ -360,8 +360,8 @@ func Test_endpointsFromSnapshot(t *testing.T) { name: "mesh-gateway-default-service-subset", create: proxycfg.TestConfigSnapshotMeshGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.MeshGateway.ServiceResolvers = map[structs.ServiceID]*structs.ServiceResolverConfigEntry{ - structs.NewServiceID("bar", nil): &structs.ServiceResolverConfigEntry{ + snap.MeshGateway.ServiceResolvers = map[structs.ServiceName]*structs.ServiceResolverConfigEntry{ + structs.NewServiceName("bar", nil): &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "bar", DefaultSubset: "v2", @@ -375,7 +375,7 @@ func Test_endpointsFromSnapshot(t *testing.T) { }, }, }, - structs.NewServiceID("foo", nil): &structs.ServiceResolverConfigEntry{ + structs.NewServiceName("foo", nil): &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "foo", DefaultSubset: "v2", @@ -481,8 +481,8 @@ func Test_endpointsFromSnapshot(t *testing.T) { name: "terminating-gateway-service-subsets", create: proxycfg.TestConfigSnapshotTerminatingGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceID]*structs.ServiceResolverConfigEntry{ - structs.NewServiceID("web", nil): { + snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceName]*structs.ServiceResolverConfigEntry{ + structs.NewServiceName("web", nil): { Kind: structs.ServiceResolver, Name: "web", Subsets: map[string]structs.ServiceResolverSubset{ @@ -495,7 +495,7 @@ func Test_endpointsFromSnapshot(t *testing.T) { }, }, }, - structs.NewServiceID("web", nil): { + structs.NewServiceName("web", nil): { Kind: structs.ServiceResolver, Name: "web", Subsets: map[string]structs.ServiceResolverSubset{ @@ -515,8 +515,8 @@ func Test_endpointsFromSnapshot(t *testing.T) { name: "terminating-gateway-default-service-subset", create: proxycfg.TestConfigSnapshotTerminatingGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceID]*structs.ServiceResolverConfigEntry{ - structs.NewServiceID("web", nil): &structs.ServiceResolverConfigEntry{ + snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceName]*structs.ServiceResolverConfigEntry{ + structs.NewServiceName("web", nil): &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "web", DefaultSubset: "v2", @@ -530,7 +530,7 @@ func Test_endpointsFromSnapshot(t *testing.T) { }, }, }, - structs.NewServiceID("web", nil): &structs.ServiceResolverConfigEntry{ + structs.NewServiceName("web", nil): &structs.ServiceResolverConfigEntry{ Kind: structs.ServiceResolver, Name: "web", DefaultSubset: "v2", diff --git a/agent/xds/listeners.go b/agent/xds/listeners.go index 3eb150c8df..cd462feb10 100644 --- a/agent/xds/listeners.go +++ b/agent/xds/listeners.go @@ -557,7 +557,7 @@ func (s *Server) makeTerminatingGatewayListener(name, addr string, port int, cfg // Make a FilterChain for each linked service // Match on the cluster name, for svc, _ := range cfgSnap.TerminatingGateway.ServiceGroups { - clusterName := connect.ServiceSNI(svc.ID, "", svc.NamespaceOrDefault(), cfgSnap.Datacenter, cfgSnap.Roots.TrustDomain) + clusterName := connect.ServiceSNI(svc.Name, "", svc.NamespaceOrDefault(), cfgSnap.Datacenter, cfgSnap.Roots.TrustDomain) resolver, hasResolver := cfgSnap.TerminatingGateway.ServiceResolvers[svc] // Skip the service if we don't have a cert to present for mTLS @@ -579,7 +579,7 @@ func (s *Server) makeTerminatingGatewayListener(name, addr string, port int, cfg if hasResolver { // generate 1 filter chain for each service subset for subsetName := range resolver.Subsets { - clusterName := connect.ServiceSNI(svc.ID, subsetName, svc.NamespaceOrDefault(), cfgSnap.Datacenter, cfgSnap.Roots.TrustDomain) + clusterName := connect.ServiceSNI(svc.Name, subsetName, svc.NamespaceOrDefault(), cfgSnap.Datacenter, cfgSnap.Roots.TrustDomain) clusterChain, err := s.sniFilterChainTerminatingGateway(name, clusterName, token, svc, cfgSnap) if err != nil { @@ -607,7 +607,7 @@ func (s *Server) makeTerminatingGatewayListener(name, addr string, port int, cfg return l, nil } -func (s *Server) sniFilterChainTerminatingGateway(listener, cluster, token string, service structs.ServiceID, +func (s *Server) sniFilterChainTerminatingGateway(listener, cluster, token string, service structs.ServiceName, cfgSnap *proxycfg.ConfigSnapshot) (envoylistener.FilterChain, error) { authFilter, err := makeExtAuthFilter(token) @@ -620,7 +620,7 @@ func (s *Server) sniFilterChainTerminatingGateway(listener, cluster, token strin } // The cluster name here doesn't matter as the sni_cluster filter will fill it in for us. - statPrefix := fmt.Sprintf("terminating_gateway_%s_%s_", service.NamespaceOrDefault(), service.ID) + statPrefix := fmt.Sprintf("terminating_gateway_%s_%s_", service.NamespaceOrDefault(), service.Name) tcpProxy, err := makeTCPProxyFilter(listener, "", statPrefix) if err != nil { return envoylistener.FilterChain{}, err diff --git a/agent/xds/listeners_test.go b/agent/xds/listeners_test.go index f8ed331a74..275f7a0838 100644 --- a/agent/xds/listeners_test.go +++ b/agent/xds/listeners_test.go @@ -361,8 +361,8 @@ func TestListenersFromSnapshot(t *testing.T) { name: "terminating-gateway-service-subsets", create: proxycfg.TestConfigSnapshotTerminatingGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceID]*structs.ServiceResolverConfigEntry{ - structs.NewServiceID("web", nil): { + snap.TerminatingGateway.ServiceResolvers = map[structs.ServiceName]*structs.ServiceResolverConfigEntry{ + structs.NewServiceName("web", nil): { Kind: structs.ServiceResolver, Name: "web", Subsets: map[string]structs.ServiceResolverSubset{ @@ -375,7 +375,7 @@ func TestListenersFromSnapshot(t *testing.T) { }, }, }, - structs.NewServiceID("web", nil): { + structs.NewServiceName("web", nil): { Kind: structs.ServiceResolver, Name: "web", Subsets: map[string]structs.ServiceResolverSubset{ @@ -423,7 +423,7 @@ func TestListenersFromSnapshot(t *testing.T) { name: "terminating-gateway-no-api-cert", create: proxycfg.TestConfigSnapshotTerminatingGateway, setup: func(snap *proxycfg.ConfigSnapshot) { - snap.TerminatingGateway.ServiceLeaves[structs.NewServiceID("api", nil)] = nil + snap.TerminatingGateway.ServiceLeaves[structs.NewServiceName("api", nil)] = nil }, }, {