package resolver

Import Path
	google.golang.org/grpc/resolver (on go.dev)

Dependency Relation
	imports 8 packages, and imported by 13 packages


Involved Source Files

	      map.go
	
		Package resolver defines APIs for name resolution in gRPC.
		All APIs in this package are experimental.


Package-Level Type Names (total 12, in which 10 are exported)


	/* sort exporteds by:  |  */
	
		Address represents a server the client connects to.

		# Experimental

		Notice: This type is EXPERIMENTAL and may be changed or removed in a
		later release.

		
			
				Addr is the server address on which a connection will be established.

			
				Attributes contains arbitrary data about this address intended for
				consumption by the SubConn.

			
				BalancerAttributes contains arbitrary data about this address intended
				for consumption by the LB policy.  These attribes do not affect SubConn
				creation, connection establishment, handshaking, etc.

			
				Metadata is the information associated with Addr, which may be used
				to make load balancing decision.

				Deprecated: use Attributes instead.

			
				ServerName is the name of this address.
				If non-empty, the ServerName is used as the transport certification authority for
				the address, instead of the hostname from the Dial target string. In most cases,
				this should not be set.

				If Type is GRPCLB, ServerName should be the name of the remote load
				balancer, not the name of the backend.

				WARNING: ServerName must only be populated with trusted values. It
				is insecure to populate it with data from untrusted inputs since untrusted
				values could be used to bypass the authority checks performed by TLS.

			
				Type is the type of this address.

				Deprecated: use Attributes instead.

		
			
				Equal returns whether a and o are identical.  Metadata is compared directly,
				not with any recursive introspection.

			
				String returns JSON formatted string representation of the address.

		
			 Address : expvar.Var
			 Address : fmt.Stringer
			
		
			func (*AddressMap).Keys() []Address
			func google.golang.org/grpc/internal.SetXDSHandshakeClusterName(addr Address, clusterName string) Address
			func google.golang.org/grpc/internal/metadata.Set(addr Address, md metadata.MD) Address
			func google.golang.org/grpc/internal/transport/networktype.Set(address Address, networkType string) Address
			
		
			func Address.Equal(o Address) bool
			func (*AddressMap).Delete(addr Address)
			func (*AddressMap).Get(addr Address) (value interface{}, ok bool)
			func (*AddressMap).Set(addr Address, value interface{})
			func ClientConn.NewAddress(addresses []Address)
			func google.golang.org/grpc/balancer.ClientConn.NewSubConn([]Address, balancer.NewSubConnOptions) (balancer.SubConn, error)
			func google.golang.org/grpc/balancer.ClientConn.UpdateAddresses(balancer.SubConn, []Address)
			func google.golang.org/grpc/balancer.SubConn.UpdateAddresses([]Address)
			func google.golang.org/grpc/internal.SetXDSHandshakeClusterName(addr Address, clusterName string) Address
			func google.golang.org/grpc/internal/metadata.Get(addr Address) metadata.MD
			func google.golang.org/grpc/internal/metadata.Set(addr Address, md metadata.MD) Address
			func google.golang.org/grpc/internal/transport.NewClientTransport(connectCtx, ctx context.Context, addr Address, opts transport.ConnectOptions, onClose func(transport.GoAwayReason)) (transport.ClientTransport, error)
			func google.golang.org/grpc/internal/transport/networktype.Get(address Address) (string, bool)
			func google.golang.org/grpc/internal/transport/networktype.Set(address Address, networkType string) Address
			


	
		AddressMap is a map of addresses to arbitrary values taking into account
		Attributes.  BalancerAttributes are ignored, as are Metadata and Type.
		Multiple accesses may not be performed concurrently.  Must be created via
		NewAddressMap; do not construct directly.

		
			
		
			
				Delete removes addr from the map.

			
				Get returns the value for the address in the map, if present.

			
				Keys returns a slice of all current map keys.

			
				Len returns the number of entries in the map.

			
				Set updates or adds the value to the address in the map.

			
				Values returns a slice of all current map values.

		
			func NewAddressMap() *AddressMap


	
		AddressType indicates the address type returned by name resolution.

		Deprecated: use Attributes in Address instead.

		
			const Backend
			const GRPCLB


	
		Builder creates a resolver that will be used to watch name resolution updates.

		
			
				Build creates a new resolver for the given target.

				gRPC dial calls Build synchronously, and fails if the returned error is
				not nil.

			
				Scheme returns the scheme supported by this resolver.
				Scheme is defined at https://github.com/grpc/grpc/blob/master/doc/naming.md.

		
			
		
			func Get(scheme string) Builder
			func google.golang.org/grpc/internal/resolver/dns.NewBuilder() Builder
			
		
			func Register(b Builder)
			func google.golang.org/grpc.WithResolvers(rs ...Builder) grpc.DialOption
			


	
		BuildOptions includes additional information for the builder to create
		the resolver.

		
			
				CredsBundle is the credentials bundle used by the ClientConn for
				communicating with the target gRPC service (set via
				WithCredentialsBundle). In cases where a name resolution service
				requires the same credentials, the resolver may use this field. In most
				cases though, it is not appropriate, and this field may be ignored.

			
				DialCreds is the transport credentials used by the ClientConn for
				communicating with the target gRPC service (set via
				WithTransportCredentials). In cases where a name resolution service
				requires the same credentials, the resolver may use this field. In most
				cases though, it is not appropriate, and this field may be ignored.

			
				Dialer is the custom dialer used by the ClientConn for dialling the
				target gRPC service (set via WithDialer). In cases where a name
				resolution service requires the same dialer, the resolver may use this
				field. In most cases though, it is not appropriate, and this field may
				be ignored.

			
				DisableServiceConfig indicates whether a resolver implementation should
				fetch service config data.

		
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)


	
		ClientConn contains the callbacks for resolver to notify any updates
		to the gRPC ClientConn.

		This interface is to be implemented by gRPC. Users should not need a
		brand new implementation of this interface. For the situations like
		testing, the new implementation should embed this interface. This allows
		gRPC to add new methods to this interface.

		
			
				NewAddress is called by resolver to notify ClientConn a new list
				of resolved addresses.
				The address list should be the complete list of resolved addresses.

				Deprecated: Use UpdateState instead.

			
				NewServiceConfig is called by resolver to notify ClientConn a new
				service config. The service config should be provided as a json string.

				Deprecated: Use UpdateState instead.

			
				ParseServiceConfig parses the provided service config and returns an
				object that provides the parsed config.

			
				ReportError notifies the ClientConn that the Resolver encountered an
				error.  The ClientConn will notify the load balancer and begin calling
				ResolveNow on the Resolver with exponential backoff.

			
				UpdateState updates the state of the ClientConn appropriately.

		
			
		
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)


	
		ResolveNowOptions includes additional information for ResolveNow.

		
			func Resolver.ResolveNow(ResolveNowOptions)
			func google.golang.org/grpc/balancer.ClientConn.ResolveNow(ResolveNowOptions)
			


	
		Resolver watches for the updates on the specified target.
		Updates include address updates and service config updates.

		
			
				Close closes the resolver.

			
				ResolveNow will be called by gRPC to try to resolve the target name
				again. It's just a hint, resolver can ignore this if it's not necessary.

				It could be called multiple times concurrently.

		
			
		
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)


	
		State contains the current Resolver state relevant to the ClientConn.

		
			
				Addresses is the latest set of resolved addresses for the target.

			
				Attributes contains arbitrary data about the resolver intended for
				consumption by the load balancing policy.

			
				ServiceConfig contains the result from parsing the latest service
				config.  If it is nil, it indicates no service config is present or the
				resolver does not provide service configs.

		
			func google.golang.org/grpc/balancer/grpclb/state.Set(state State, s *state.State) State
			func google.golang.org/grpc/internal/resolver.SetConfigSelector(state State, cs resolver.ConfigSelector) State
		
			func ClientConn.UpdateState(State) error
			func google.golang.org/grpc/balancer/grpclb/state.Get(state State) *state.State
			func google.golang.org/grpc/balancer/grpclb/state.Set(state State, s *state.State) State
			func google.golang.org/grpc/internal/resolver.GetConfigSelector(state State) resolver.ConfigSelector
			func google.golang.org/grpc/internal/resolver.SetConfigSelector(state State, cs resolver.ConfigSelector) State
			


	
		Target represents a target for gRPC, as specified in:
		https://github.com/grpc/grpc/blob/master/doc/naming.md.
		It is parsed from the target string that gets passed into Dial or DialContext
		by the user. And gRPC passes it to the resolver and the balancer.

		If the target follows the naming spec, and the parsed scheme is registered
		with gRPC, we will parse the target string according to the spec. If the
		target does not contain a scheme or if the parsed scheme is not registered
		(i.e. no corresponding resolver available to resolve the endpoint), we will
		apply the default scheme, and will attempt to reparse it.

		Examples:

		  - "dns://some_authority/foo.bar"
		    Target{Scheme: "dns", Authority: "some_authority", Endpoint: "foo.bar"}
		  - "foo.bar"
		    Target{Scheme: resolver.GetDefaultScheme(), Endpoint: "foo.bar"}
		  - "unknown_scheme://authority/endpoint"
		    Target{Scheme: resolver.GetDefaultScheme(), Endpoint: "unknown_scheme://authority/endpoint"}

		
			
				Deprecated: use URL.Host instead.

			
				Deprecated: use URL.Scheme instead.

			
				URL contains the parsed dial target with an optional default scheme added
				to it if the original dial target contained no scheme or contained an
				unregistered scheme. Any query params specified in the original dial
				target can be accessed from here.

		
			
				Endpoint retrieves endpoint without leading "/" from either `URL.Path`
				or `URL.Opaque`. The latter is used when the former is empty.

		
			
		
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)


	


Package-Level Functions (total 7, in which 6 are exported)


	
		Get returns the resolver builder registered with the given scheme.

		If no builder is register with the scheme, nil will be returned.


	
		GetDefaultScheme gets the default scheme that will be used.


	
		NewAddressMap creates a new AddressMap.


	
		Register registers the resolver builder to the resolver map. b.Scheme will be
		used as the scheme registered with this builder.

		NOTE: this function must only be called during initialization time (i.e. in
		an init() function), and is not thread-safe. If multiple Resolvers are
		registered with the same name, the one registered last will take effect.


	
		SetDefaultScheme sets the default scheme that will be used. The default
		default scheme is "passthrough".

		NOTE: this function must only be called during initialization time (i.e. in
		an init() function), and is not thread-safe. The scheme set last overrides
		previously set values.


	
		UnregisterForTesting removes the resolver builder with the given scheme from the
		resolver map.
		This function is for testing only.


	


Package-Level Variables (total 2, neither is exported)

	


Package-Level Constants (total 2, both are exported)


	
		Backend indicates the address is for a backend server.

		Deprecated: use Attributes in Address instead.


	
		GRPCLB indicates the address is for a grpclb load balancer.

		Deprecated: to select the GRPCLB load balancing policy, use a service
		config with a corresponding loadBalancingConfig.  To supply balancer
		addresses to the GRPCLB load balancing policy, set State.Attributes
		using balancer/grpclb/state.Set.