package resolver

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

Dependency Relation
	imports 5 packages, and imported by 9 packages

Involved Source Files

	   d➜ resolver.go
		Package resolver defines APIs for name resolution in gRPC.
		All APIs in this package are experimental.
Package-Level Type Names (total 9, all are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Address (struct)
		Address represents a server the client connects to.
		This is the EXPERIMENTAL API and may be changed or extended in the future.

		Fields (total 5, all are exported)
			Addr string
				Addr is the server address on which a connection will be established.

			Attributes *attributes.Attributes
				Attributes contains arbitrary data about this address intended for
				consumption by the load balancing policy.

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

				Deprecated: use Attributes instead.

			ServerName string
				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 AddressType
				Type is the type of this address.

				Deprecated: use Attributes instead.

		As Inputs Of (at least 8, in which 4 are exported)
			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.SubConn.UpdateAddresses([]Address)
			func google.golang.org/grpc/internal/transport.NewClientTransport(connectCtx, ctx context.Context, addr Address, opts transport.ConnectOptions, onPrefaceReceipt func(), onGoAway func(transport.GoAwayReason), onClose func()) (transport.ClientTransport, error)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func google.golang.org/grpc.(*ClientConn).applyServiceConfigAndBalancer(sc *grpc.ServiceConfig, addrs []Address)
			func google.golang.org/grpc.(*ClientConn).maybeApplyDefaultServiceConfig(addrs []Address)
			func google.golang.org/grpc.(*ClientConn).newAddrConn(addrs []Address, opts balancer.NewSubConnOptions) (*grpc.addrConn, error)
			func google.golang.org/grpc/internal/transport.newHTTP2Client(connectCtx, ctx context.Context, addr Address, opts transport.ConnectOptions, onPrefaceReceipt func(), onGoAway func(transport.GoAwayReason), onClose func()) (_ *transport.http2Client, err error)

	 type AddressType uint8 (basic type)
		AddressType indicates the address type returned by name resolution.

		Deprecated: use Attributes in Address instead.

		As Types Of (total 2, both are exported)
			const Backend
			const GRPCLB

	 type Builder (interface)
		Builder creates a resolver that will be used to watch name resolution updates.

		Methods (total 2, both are exported)
			( T) Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)
				Build creates a new resolver for the given target.

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

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

		Implemented By (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*google.golang.org/grpc/balancer/grpclb.lbManualResolver
			*google.golang.org/grpc/internal/resolver/dns.dnsBuilder
			*google.golang.org/grpc/internal/resolver/passthrough.passthroughBuilder
		As Outputs Of (at least 3, in which 2 are exported)
			func Get(scheme string) Builder
			func google.golang.org/grpc/internal/resolver/dns.NewBuilder() Builder
			/* at least one unexported ... *//* at least one unexported: */
			func google.golang.org/grpc.(*ClientConn).getResolver(scheme string) Builder
		As Inputs Of (at least 3, in which 2 are exported)
			func Register(b Builder)
			func google.golang.org/grpc.WithResolvers(rs ...Builder) grpc.DialOption
			/* at least one unexported ... *//* at least one unexported: */
			func google.golang.org/grpc.newCCResolverWrapper(cc *grpc.ClientConn, rb Builder) (*grpc.ccResolverWrapper, error)

	 type BuildOptions (struct)
		BuildOptions includes additional information for the builder to create
		the resolver.

		Fields (total 4, all are exported)
			CredsBundle credentials.Bundle
				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 credentials.TransportCredentials
				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 func(context.Context, string) (net.Conn, error)
				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 bool
				DisableServiceConfig indicates whether a resolver implementation should
				fetch service config data.

		As Inputs Of (at least one exported)
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)

	 type ClientConn (interface)
		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.

		Methods (total 5, all are exported)
			( T) NewAddress(addresses []Address)
				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.

			( T) NewServiceConfig(serviceConfig string)
				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.

			( T) ParseServiceConfig(serviceConfigJSON string) *serviceconfig.ParseResult
				ParseServiceConfig parses the provided service config and returns an
				object that provides the parsed config.

			( T) ReportError(error)
				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.

			( T) UpdateState(State)
				UpdateState updates the state of the ClientConn appropriately.

		Implemented By (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*google.golang.org/grpc.ccResolverWrapper
		As Inputs Of (at least one exported)
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)

	 type ResolveNowOptions (struct)
		ResolveNowOptions includes additional information for ResolveNow.

		As Inputs Of (at least 3, in which 2 are exported)
			func Resolver.ResolveNow(ResolveNowOptions)
			func google.golang.org/grpc/balancer.ClientConn.ResolveNow(ResolveNowOptions)
			/* at least one unexported ... *//* at least one unexported: */
			func google.golang.org/grpc.(*ClientConn).resolveNow(o ResolveNowOptions)

	 type Resolver (interface)
		Resolver watches for the updates on the specified target.
		Updates include address updates and service config updates.

		Methods (total 2, both are exported)
			( T) Close()
				Close closes the resolver.

			( T) ResolveNow(ResolveNowOptions)
				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.

		Implemented By (at least 4, none are exported)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			*google.golang.org/grpc/balancer/grpclb.lbManualResolver
			 google.golang.org/grpc/internal/resolver/dns.deadResolver
			*google.golang.org/grpc/internal/resolver/dns.dnsResolver
			*google.golang.org/grpc/internal/resolver/passthrough.passthroughResolver
		As Outputs Of (at least one exported)
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)

	 type State (struct)
		State contains the current Resolver state relevant to the ClientConn.

		Fields (total 3, all are exported)
			Addresses []Address
				Addresses is the latest set of resolved addresses for the target.

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

			ServiceConfig *serviceconfig.ParseResult
				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.

		As Outputs Of (at least one exported)
			func google.golang.org/grpc/balancer/grpclb/state.Set(state State, s *state.State) State
		As Inputs Of (at least 4, in which 3 are exported)
			func ClientConn.UpdateState(State)
			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
			/* at least one unexported ... *//* at least one unexported: */
			func google.golang.org/grpc.(*ClientConn).updateResolverState(s State, err error) error

	 type Target (struct)
		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. e.g. "dns://some_authority/foo.bar" will be parsed
		into &Target{Scheme: "dns", Authority: "some_authority", Endpoint: "foo.bar"}

		If the target does not contain a scheme, we will apply the default scheme, and set the Target to
		be the full target string. e.g. "foo.bar" will be parsed into
		&Target{Scheme: resolver.GetDefaultScheme(), Endpoint: "foo.bar"}.

		If the parsed scheme is not registered (i.e. no corresponding resolver available to resolve the
		endpoint), we set the Scheme to be the default scheme, and set the Endpoint to be the full target
		string. e.g. target string "unknown_scheme://authority/endpoint" will be parsed into
		&Target{Scheme: resolver.GetDefaultScheme(), Endpoint: "unknown_scheme://authority/endpoint"}.

		Fields (total 3, all are exported)
			Authority string
			Endpoint string
			Scheme string
		As Outputs Of (at least one exported)
			func google.golang.org/grpc/internal/grpcutil.ParseTarget(target string) (ret Target)
		As Inputs Of (at least one exported)
			func Builder.Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)


Package-Level Functions (total 5, all are exported)

	 func Get(scheme string) Builder
		Get returns the resolver builder registered with the given scheme.

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

	 func GetDefaultScheme() string
		GetDefaultScheme gets the default scheme that will be used.

	 func Register(b Builder)
		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.

	 func SetDefaultScheme(scheme string)
		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.

	 func UnregisterForTesting(scheme string)
		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)

	/* 2 unexporteds ... *//* 2 unexporteds: */
	  var defaultScheme string
		defaultScheme is the default scheme to use.

	  var m map[string]Builder
		m is a map from scheme to resolver builder.


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

	const Backend AddressType = 0
		Backend indicates the address is for a backend server.

		Deprecated: use Attributes in Address instead.

	const GRPCLB AddressType = 1
		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.

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.