Simplified interfaces and optimized resolver matching logic

Signed-off-by: Alexandros Filios <alexandros.filios@ibm.com>

Author: alexandrosfilios

platform/view/core/endpoint/endpoint.go

@@ -35,6 +35,14 @@ type Resolver struct {
 	IdentityGetter func() (view.Identity, []byte, error)
 }
 
+func (r *Resolver) GetName() string { return r.Name }
+
+func (r *Resolver) GetId() view.Identity { return r.Id }
+
+func (r *Resolver) GetAddress(port driver.PortName) string { return r.Addresses[port] }
+
+func (r *Resolver) GetAddresses() map[driver.PortName]string { return r.Addresses }
+
 func (r *Resolver) GetIdentity() (view.Identity, error) {
 	if r.IdentityGetter != nil {
 		id, _, err := r.IdentityGetter()
@@ -75,38 +83,36 @@ func NewService(binder Binder) (*Service, error) {
 	return er, nil
 }
 
-func (r *Service) Endpoint(party view.Identity) (map[driver.PortName]string, error) {
-	_, e, _, err := r.resolve(party)
-	return e, err
-}
-
-func (r *Service) Resolve(party view.Identity) (string, view.Identity, map[driver.PortName]string, []byte, error) {
-	cursor, e, resolver, err := r.resolve(party)
+func (r *Service) Resolve(party view.Identity) (driver.Resolver, []byte, error) {
+	resolver, err := r.resolver(party)
 	if err != nil {
-		return "", nil, nil, nil, err
+		return nil, nil, err
 	}
-	return resolver.Name, cursor, e, r.pkiResolve(resolver), nil
+	return resolver, r.pkiResolve(resolver), nil
 }
 
-func (r *Service) resolve(party view.Identity) (view.Identity, map[driver.PortName]string, *Resolver, error) {
+func (r *Service) GetResolver(party view.Identity) (driver.Resolver, error) {
+	return r.resolver(party)
+}
 
+func (r *Service) resolver(party view.Identity) (*Resolver, error) {
 	// We can skip this check, but in case the long term was passed directly, this is going to spare us a DB lookup
-	resolver, e, err := r.rootEndpoint(party)
+	resolver, err := r.rootEndpoint(party)
 	if err == nil {
-		return party, e, resolver, nil
+		return resolver, nil
 	}
 	logger.Debugf("resolving via binding for %s", party)
 	party, err = r.binder.GetLongTerm(party)
 	if err != nil {
-		return nil, nil, nil, err
+		return nil, err
 	}
 	logger.Debugf("continue to [%s]", party)
-	resolver, e, err = r.rootEndpoint(party)
+	resolver, err = r.rootEndpoint(party)
 	if err != nil {
-		return nil, nil, nil, err
+		return nil, err
 	}
 
-	return party, e, resolver, nil
+	return resolver, nil
 }
 
 func (r *Service) Bind(longTerm view.Identity, ephemeral view.Identity) error {
@@ -138,14 +144,7 @@ func (r *Service) GetIdentity(endpoint string, pkID []byte) (view.Identity, erro
 
 	// search in the resolver list
 	for _, resolver := range r.resolvers {
-		resolverPKID := r.pkiResolve(resolver)
-
-		if endpoint == resolver.Name ||
-			endpoint == resolver.Name+"."+resolver.Domain ||
-			collections.ContainsValue(resolver.Addresses, endpoint) ||
-			slices.Contains(resolver.Aliases, endpoint) ||
-			bytes.Equal(pkID, resolver.Id) ||
-			bytes.Equal(pkID, resolverPKID) {
+		if r.matchesResolver(endpoint, pkID, resolver) {
 
 			id, err := resolver.GetIdentity()
 			if err != nil {
@@ -160,6 +159,18 @@ func (r *Service) GetIdentity(endpoint string, pkID []byte) (view.Identity, erro
 	return nil, errors.Errorf("identity not found at [%s,%s]", endpoint, view.Identity(pkID))
 }
 
+func (r *Service) matchesResolver(endpoint string, pkID []byte, resolver *Resolver) bool {
+	if len(endpoint) > 0 && (endpoint == resolver.Name ||
+		endpoint == resolver.Name+"."+resolver.Domain ||
+		collections.ContainsValue(resolver.Addresses, endpoint) ||
+		slices.Contains(resolver.Aliases, endpoint)) {
+		return true
+	}
+
+	return len(pkID) > 0 && (bytes.Equal(pkID, resolver.Id) ||
+		bytes.Equal(pkID, r.pkiResolve(resolver)))
+}
+
 func (r *Service) AddResolver(name string, domain string, addresses map[string]string, aliases []string, id []byte) (view.Identity, error) {
 	if logger.IsEnabledFor(zapcore.DebugLevel) {
 		logger.Debugf("adding resolver [%s,%s,%v,%v,%s]", name, domain, addresses, aliases, view.Identity(id).String())
@@ -251,17 +262,17 @@ func (r *Service) ExtractPKI(id []byte) []byte {
 	return nil
 }
 
-func (r *Service) rootEndpoint(party view.Identity) (*Resolver, map[driver.PortName]string, error) {
+func (r *Service) rootEndpoint(party view.Identity) (*Resolver, error) {
 	r.resolversMutex.RLock()
 	defer r.resolversMutex.RUnlock()
 
 	for _, resolver := range r.resolvers {
 		if bytes.Equal(resolver.Id, party) {
-			return resolver, resolver.Addresses, nil
+			return resolver, nil
 		}
 	}
 
-	return nil, nil, errors.Errorf("endpoint not found for identity %s", party.UniqueID())
+	return nil, errors.Errorf("endpoint not found for identity %s", party.UniqueID())
 }
 
 var portNameMap = map[string]driver.PortName{

platform/view/core/manager/context.go

@@ -334,19 +334,19 @@ func (ctx *ctx) Dispose() {
 }
 
 func (ctx *ctx) newSession(view view.View, contextID string, party view.Identity) (view.Session, error) {
-	_, _, endpoints, pkid, err := ctx.resolver.Resolve(party)
+	resolver, pkid, err := ctx.resolver.Resolve(party)
 	if err != nil {
 		return nil, err
 	}
-	return ctx.sessionFactory.NewSession(getIdentifier(view), contextID, endpoints[driver.P2PPort], pkid)
+	return ctx.sessionFactory.NewSession(getIdentifier(view), contextID, resolver.GetAddress(driver.P2PPort), pkid)
 }
 
 func (ctx *ctx) newSessionByID(sessionID, contextID string, party view.Identity) (view.Session, error) {
-	_, _, endpoints, pkid, err := ctx.resolver.Resolve(party)
+	resolver, pkid, err := ctx.resolver.Resolve(party)
 	if err != nil {
 		return nil, err
 	}
-	return ctx.sessionFactory.NewSessionWithID(sessionID, contextID, endpoints[driver.P2PPort], pkid, nil, nil)
+	return ctx.sessionFactory.NewSessionWithID(sessionID, contextID, resolver.GetAddress(driver.P2PPort), pkid, nil, nil)
 }
 
 func (ctx *ctx) cleanup() {

platform/view/driver/endpointservice.go

@@ -36,12 +36,20 @@ type PublicKeyIDSynthesizer interface {
 
 //go:generate counterfeiter -o mock/resolver.go -fake-name EndpointService . EndpointService
 
+type Resolver interface {
+	GetName() string
+	GetId() view.Identity
+	GetAddress(port PortName) string
+	GetAddresses() map[PortName]string
+}
+
 // EndpointService models the endpoint service
 type EndpointService interface {
 	// Resolve returns the identity the passed identity is bound to.
 	// It returns also: the endpoints and the pkiID
-	Resolve(party view.Identity) (string, view.Identity, map[PortName]string, []byte, error)
-
+	Resolve(party view.Identity) (Resolver, []byte, error)
+	// GetResolver returns the identity the passed identity is bound to
+	GetResolver(party view.Identity) (Resolver, error)
 	// GetIdentity returns an identity bound to either the passed label or public-key identifier.
 	GetIdentity(label string, pkiID []byte) (view.Identity, error)