multiclient

type Caller func(req *client.Request, rsp proto.Message) errors.Error

type Errors interface {
	error

	// IgnoreUid removes all errors for the given request uid(s)
	IgnoreUid(uids ...string) Errors
	// IgnoreService removes all errors for requests to the given service(s)
	IgnoreService(services ...string) Errors
	// IgnoreEndpoint removes all errors to a given service endpoint
	IgnoreEndpoint(service, endpoint string) Errors
	// IgnoreType removes all errors of the given type(s)
	IgnoreType(types ...string) Errors
	// IgnoreCode removes all errors with the given code(s)
	IgnoreCode(codes ...string) Errors
	// Errors returns all matching errors, mapped to their request uid
	Errors() map[string]errors.Error
	// Count returns a count of matching errors
	Count() int
	// AnyErrors returns whether there are any contained errors
	AnyErrors() bool
	// ForUid returns the error for a given request uid (or nil)
	ForUid(uid string) errors.Error
	// Suffix sets a dotted suffix to add to any returned errors
	Suffix(suffix string) Errors
	// Combined returns a platform error with the given suffix, scoped correctly (or nil)
	Combined() errors.Error
	// MultiError returns a combined MultiError
	MultiError() *multierror.MultiError
}

type Mock struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type MultiClient interface {
	// DefaultScopeFrom defines a server request that we can leverage for scoping, meaning that any
	// `ScopedReq`s added don't have to include the From scope
	DefaultScopeFrom(s Scoper) MultiClient
	// SetCaller optionally defines a caller for use with this multiclient request (overrides the default)
	SetCaller(c Caller) MultiClient
	// AddScopedReq adds a server-scoped request (from the server request `from`) to our multi-client
	// with the `uid` that uniquely identifies the request within the group (for getting response from `Outcome`)
	AddScopedReq(sr *ScopedReq) MultiClient
	// Reset removes all scoped requests/results ready for re-use
	Reset() MultiClient
	// Execute runs all requests in parallel, blocking until all have completed
	Execute() MultiClient
	// AnyErrors will return true if ANY request resulted in an error
	AnyErrors() bool
	// AnyErrorsIgnoring will return true if ANY request resulted in an error, but ignoring the supplied types/codes
	AnyErrorsIgnoring(types []string, codes []string) bool
	// PlatformError mints a new platform error, with the specified code suffix (and server namespace prefix),
	// describing all errors that occurred
	PlatformError(codeSuffix string) errors.Error
	// Errors returns Errors representing all errors that occurred
	Errors() Errors
	// Succeeded tests if request with this uid had an error
	Succeeded(uid string) errors.Error
	// Response returns the response for request uid
	Response(uid string) proto.Message
}

type Options struct {
	BaseUrl               string
	TlsSkipVerify         bool
	ConnectTimeout        time.Duration
	RequestTimeout        time.Duration
	ResponseHeaderTimeout time.Duration
}

type Responder func(invocation int, req *client.Request) (proto.Message, errors.Error)

type ScopedReq struct {
	Uid      string
	From     Scoper
	Service  string
	Endpoint string
	Req      proto.Message
	Rsp      proto.Message
	Options  client.Options
}

type Scoper interface {
	// Name returns the scope name, for example the server name, or scoping request name,
	// which can be used to give context to error messages etc.
	Context() string
	// ScopedRequest yields a new RPC request, preserving scope of trace/auth etc.
	ScopedRequest(service, endpoint string, payload proto.Message) (*client.Request, error)
}

type Stub struct {
	Service, Endpoint string

	Response  proto.Message // Response to return on every matched request
	Error     errors.Error  // Error to return on every matched request
	Responder Responder     // Responder function to use to give more control over exact response
	// contains filtered or unexported fields
}