blaze

type AbortedErrorType ¶

type AbortedErrorType struct{}

AbortedErrorType indicates the operation was aborted, typically due to a concurrency issue like sequencer check failures, transaction aborts, etc.

func (e *AbortedErrorType) Error() string

type AlreadyExistsErrorType ¶

type AlreadyExistsErrorType struct{}

AlreadyExistsErrorType means an attempt to create an entity failed because one already exists

func (e *AlreadyExistsErrorType) Error() string

type BadRouteErrorType ¶

type BadRouteErrorType struct{}

BadRouteErrorType means that the requested URL path wasn't routable to a blaze service and method. This is returned by the generated server, and usually shouldn't be returned by applications. Instead, applications should use NotFound or Unimplemented.

func (e *BadRouteErrorType) Error() string

type CanceledErrorType ¶

type CanceledErrorType struct{}

CanceledErrorType indicates the operation was cancelled (typically by the caller).

func (e *CanceledErrorType) Error() string

type ClientOption ¶ added in v0.0.2

type ClientOption func(*ClientOptions)

ClientOption is a functional option for extending a Blaze client.

type ClientOptions ¶ added in v0.0.2

type ClientOptions struct {
	// Trace implementation for distributed tracing
	Trace blazetrace.ClientTracer
}

ClientOptions encapsulate the configurable parameters on a Blaze client.

type DataLossErrorType ¶

type DataLossErrorType struct{}

DataLossErrorType indicates unrecoverable data loss or corruption.

func (e *DataLossErrorType) Error() string

type DeadlineExceededErrorType ¶

type DeadlineExceededErrorType struct{}

DeadlineExceededErrorType means operation expired before completion. For operations that change the state of the system, this error may be returned even if the operation has completed successfully (timeout).

func (e *DeadlineExceededErrorType) Error() string

type Error ¶

type Error interface {
	// Type returns the type of the error
	Type() string
	// Msg returns a human-readable, unstructured messages describing the error.
	Msg() string

	// WithMeta returns a copy of the Error with the given key-value pair attached
	// as metadata. If the key is already set, it is overwritten.
	WithMeta(key string, val string) Error

	// Meta returns the stored value for the given key. If the key has no set
	// value, Meta returns an empty string. There is no way to distinguish between
	// an unset value and an explicit empty string.
	Meta(key string) string

	// MetaMap returns a copy of the complete key-value metadata map stored on the error.
	MetaMap() map[string]string

	// Error returns a string of the form "blaze error <Type>: <Msg>"
	Error() string

	//Unwrap returns the wrapped error
	Unwrap() error
}

Error represents an error in a Blaze service call.

func ErrorAborted(msg string) Error

func ErrorAlreadyExists(msg string) Error

func ErrorBadRoute(msg string) Error

func ErrorCanceled(msg string) Error

func ErrorDataLoss(msg string) Error

func ErrorDeadlineExeeded(msg string) Error

func ErrorFailedPrecondition(msg string) Error

func ErrorFromResponse(resp *http.Response) Error

func ErrorInternal(msg string) Error

func ErrorInternalWith(err error, msg string) Error

func ErrorInvalidArgument(argument string, validationMsg string) Error

func ErrorJSONToError(j ErrorJSON) (Error, error)

func ErrorMalformed(msg string) Error

func ErrorNotFound(msg string) Error

func ErrorOutOfRange(msg string) Error

func ErrorPermissionDenied(msg string) Error

func ErrorRequiredArgument(argument string) Error

func ErrorResourceExhausted(msg string) Error

func ErrorUnauthenticated(msg string) Error

func ErrorUnavailable(msg string) Error

func ErrorUnimplemented(msg string) Error

func ErrorUnknown(msg string) Error

func NewError(err error, msg string) Error

type ErrorJSON ¶ added in v0.0.2

type ErrorJSON struct {
	Code string            `json:"code"`
	Msg  string            `json:"msg"`
	Type string            `json:"blaze_type"`
	Meta map[string]string `json:"meta,omitempty"`
}

ErrorJSON is JSON serialization for blaze errors

func ErrorToErrorJSON(e Error) (ErrorJSON, error)

type FailedPreconditionErrorType ¶

type FailedPreconditionErrorType struct{}

FailedPreconditionErrorType indicates operation was rejected because the system is not in a state required for the operation's execution. For example, doing an rmdir operation on a directory that is non-empty, or on a non-directory object, or when having conflicting read-modify-write on the same resource.

func (e *FailedPreconditionErrorType) Error() string

type HTTPClient ¶ added in v0.0.2

type HTTPClient interface {
	Do(req *http.Request) (*http.Response, error)
}

HTTPClient is the interface used by generated clients to send HTTP requests. It is fulfilled by *(net/http).Client, which is sufficient for most users. Users can provide their own implementation for special retry policies.

HTTPClient implementations should not follow redirects. Redirects are automatically disabled if *(net/http).Client is passed to client constructors. See the withoutRedirects function in this file for more details.

type InternalErrorType ¶

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

InternalErrorType error is an error produced by a downstream dependency of blaze

func (e *InternalErrorType) Error() string

func (e *InternalErrorType) Unwrap() error

type InvalidArgumentErrorType ¶

type InvalidArgumentErrorType struct{}

InvalidArgumentErrorType indicates client specified an invalid argument. It indicates arguments that are problematic regardless of the state of the system (i.e. a malformed file name, required argument, number out of range, etc.).

func (e *InvalidArgumentErrorType) Error() string

type MalformedErrorType ¶

type MalformedErrorType struct{}

MalformedErrorType indicates an error occured while decoding the client's request. This means that the message was encoded improperly, or that there is an disagreement in message format between client and server

func (e *MalformedErrorType) Error() string

type NotFoundErrorType ¶

type NotFoundErrorType struct{}

NotFoundErrorType indicates a common NotFound error

func (e *NotFoundErrorType) Error() string

type OutOfRangeErrorType ¶

type OutOfRangeErrorType struct{}

OutOfRangeErrorType means operation was attempted past the valid range. For example, seeking or reading past end of a paginated collection.

Unlike InvalidArgument, this error indicates a problem that may be fixed if the system state changes (i.e. adding more items to the collection).

There is a fair bit of overlap between FailedPrecondition and OutOfRange. We recommend using OutOfRange (the more specific error) when it applies so that callers who are iterating through a space can easily look for an OutOfRange error to detect when they are done.

func (e *OutOfRangeErrorType) Error() string

type PermissionDeniedErrorType ¶

type PermissionDeniedErrorType struct{}

PermissionDeniedErrorType indicates the caller does not have permission to execute the specified operation. It must not be used if the caller cannot be identified (Unauthenticated).

func (e *PermissionDeniedErrorType) Error() string

type ResourceExhaustedErrorType ¶

type ResourceExhaustedErrorType struct{}

ResourceExhaustedErrorType indicates some resource has been exhausted, perhaps a per-user quota, or perhaps the entire file system is out of space.

func (e *ResourceExhaustedErrorType) Error() string

type Service ¶ added in v0.0.4

type Service interface {
	Mux() *chi.Mux
	MountPath() string
}

Service defines the interface of blazeservice

type ServiceOption ¶ added in v0.0.4

type ServiceOption func(*ServiceOptions)

ServiceOption is a functional option for extending a Blaze service.

func WithJSONEmitDefaults(v bool) ServiceOption

func WithJSONEnumsAsInts(v bool) ServiceOption

func WithMux(mux *chi.Mux) ServiceOption

func WithServiceTracer(trace blazetrace.ServiceTracer) ServiceOption

type ServiceOptions ¶ added in v0.0.4

type ServiceOptions struct {
	// Uses a specific mux instead of chi.NewRouter()
	Mux *chi.Mux
	// Whether to render enum values as integers, as opposed to string values.
	JSONEnumsAsInts bool
	// Whether to render fields with zero values.
	JSONEmitDefaults bool
	// Trace implementation for distributed tracing
	Trace blazetrace.ServiceTracer
}

ServiceOptions encapsulate the configurable parameters on a Blaze service.

type UnauthenticatedErrorType ¶

type UnauthenticatedErrorType struct{}

UnauthenticatedErrorType indicates the request does not have valid authentication credentials for the operation.

func (e *UnauthenticatedErrorType) Error() string

type UnavailableErrorType ¶

type UnavailableErrorType struct{}

UnavailableErrorType indicates the service is currently unavailable. This is a most likely a transient condition and may be corrected by retrying with a backoff.

func (e *UnavailableErrorType) Error() string

type UnimplementedErrorType ¶

type UnimplementedErrorType struct{}

UnimplementedErrorType indicates operation is not implemented or not supported/enabled in this service.

func (e *UnimplementedErrorType) Error() string

type UnknownErrorType ¶

type UnknownErrorType struct{}

UnknownErrorType For example handling errors raised by APIs that dont return enough error information

func (e *UnknownErrorType) Error() string