discoverkit

type Application struct {
	// Identity is the application's identity.
	Identity configkit.Identity

	// Target is the gRPC target that is hosting the application.
	Target Target

	// Connection is the connection that was used to discover the application.
	Connection grpc.ClientConnInterface
}

type ApplicationDiscoverer struct {
	// Dial is the function used to dial gRPC targets.
	//
	// If it is nil, grpc.DialContext() is used.
	Dial Dialer

	// BackoffStrategy is the strategy that determines when to retry watching a
	// gRPC target for application availability changes.
	BackoffStrategy backoff.Strategy

	// LogError is an optional function that logs errors that occur while
	// attempting to watch a gRPC target.
	LogError func(Target, error)
}

type ApplicationObserver func(ctx context.Context, a Application)

type DNSTargetDiscoverer struct {
	// QueryHost is the hostname that is queried.
	QueryHost string

	// NewTargets returns the targets that are discovered based on the addition
	// of a new network address to the DNS query result.
	//
	// addr is the address discovered by the DNS query. It may be a hostname or
	// an IP address.
	//
	// If NewTargets is nil the discoverer constructs a single Target for each
	// discovered address. The target name is built using the discovered address
	// as the host and the DefaultGRPCPort constant for the port.
	NewTargets func(ctx context.Context, addr string) (targets []Target, err error)

	// LookupHost is the function used to query the host.
	//
	// If it is nil, net.DefaultResolver.LookupHost() is used.
	LookupHost func(ctx context.Context, host string) (addresses []string, err error)

	// QueryInterval is the interval at which DNS queries are performed.
	//
	// If it is non-positive, the DefaultDNSQueryInterval constant is used.
	QueryInterval time.Duration
}

type Dialer func(context.Context, string, ...grpc.DialOption) (*grpc.ClientConn, error)

type KubernetesEnvironmentTargetDiscoverer struct {
	// PortName is the name (not the number) of the port used to identify a
	// Dogma target.
	//
	// If it is empty, DefaultKubernetesPortName is used.
	PortName string

	// DialOptions returns the dial options used to dial the given address.
	DialOptions func(addr string) []grpc.DialOption
}

type Server struct {
	// contains filtered or unexported fields
}

type StaticTargetDiscoverer []Target

type Target struct {
	// Name is the target name used to dial the target.
	//
	// Typically this is the hostname and port of a single gRPC server but it
	// may use any of the naming schemes defined in
	// https://github.com/grpc/grpc/blob/master/doc/naming.md.
	Name string

	// DialOptions is a set of grpc.DialOptions used when dialing this target.
	DialOptions []grpc.DialOption
}

type TargetDiscoverer interface {
	// DiscoverTargets invokes an observer for each gRPC target that is
	// discovered.
	//
	// It runs until ctx is canceled or an error occurs.
	//
	// The context passed to the observer is canceled when the target becomes
	// unavailable or the discover is stopped.
	//
	// The discoverer MAY block on calls to the observer. It is the observer's
	// responsibility to start new goroutines to handle background tasks, as
	// appropriate.
	DiscoverTargets(ctx context.Context, obs TargetObserver) error
}

type TargetObserver func(ctx context.Context, t Target)