template

package
v0.0.0-...-5ed5411 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Feb 6, 2023 License: BSD-3-Clause Imports: 13 Imported by: 8

Documentation

Index

Examples

Constants

View Source
const (
	BeginDelimiter = "{"
	EndDelimiter   = "}"
)
View Source
const (
	ContentType     = "Content-Type"
	ContentTypeText = "text/plain" // charset=utf-8
	ContentTypeJson = "application/json"
	NilDuration     = time.Duration(-1)
)
View Source
const (
	StatusInvalidContent     = codes.Code(90)           // Content is not available, is nil, or is of the wrong type, usually found via unmarshalling
	StatusIOError            = codes.Code(91)           // I/O operation failed
	StatusJsonDecodeError    = codes.Code(92)           // Json decoding failed
	StatusNotProvided        = codes.Code(93)           // No status is available
	StatusRateLimited        = codes.Code(94)           // Rate limited
	StatusOK                 = codes.OK                 // Not an error; returned on success.
	StatusCancelled          = codes.Canceled           // The operation was cancelled, typically by the caller.
	StatusUnknown            = codes.Unknown            // Unknown error. For example, this error may be returned when a Status value received from another address space belongs to an error space that is not known in this address space. Also errors raised by APIs that do not return enough error information may be converted to this error.
	StatusInvalidArgument    = codes.InvalidArgument    // The client specified an invalid argument. Note that this differs from FAILED_PRECONDITION. INVALID_ARGUMENT indicates arguments that are problematic regardless of the state of the system (e.g., a malformed file name).
	StatusDeadlineExceeded   = codes.DeadlineExceeded   // The deadline expired before the operation could complete. For operations that change the state of the system, this error may be returned even if the operation has completed successfully. For example, a successful response from a server could have been delayed long
	StatusNotFound           = codes.NotFound           // Some requested entity (e.g., file or directory) was not found. Note to server developers: if a request is denied for an entire class of users, such as gradual feature rollout or undocumented allowlist, NOT_FOUND may be used. If a request is denied for some users within a class of users, such as user-based access control, PERMISSION_DENIED must be used.
	StatusAlreadyExists      = codes.AlreadyExists      // The entity that a client attempted to create (e.g., file or directory) already exists.
	StatusPermissionDenied   = codes.PermissionDenied   // The caller does not have permission to execute the specified operation. PERMISSION_DENIED must not be used for rejections caused by exhausting some resource (use RESOURCE_EXHAUSTED instead for those errors). PERMISSION_DENIED must not be used if the caller can not be identified (use UNAUTHENTICATED instead for those errors). This error code does not imply the request is valid or the requested entity exists or satisfies other pre-conditions.
	StatusResourceExhausted  = codes.ResourceExhausted  // Some resource has been exhausted, perhaps a per-user quota, or perhaps the entire file system is out of space.
	StatusFailedPrecondition = codes.FailedPrecondition // The operation was rejected because the system is not in a state required for the operation's execution. For example, the directory to be deleted is non-empty, an rmdir operation is applied to a non-directory, etc. Service implementors can use the following guidelines to decide between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE: (a) Use UNAVAILABLE if the client can retry just the failing call. (b) Use ABORTED if the client should retry at a higher level (e.g., when a client-specified test-and-set fails, indicating the client should restart a read-modify-write sequence). (c) Use FAILED_PRECONDITION if the client should not retry until the system state has been explicitly fixed. E.g., if an "rmdir" fails because the directory is non-empty, FAILED_PRECONDITION should be returned since the client should not retry unless the files are deleted from the directory.
	StatusAborted            = codes.Aborted            // The operation was aborted, typically due to a concurrency issue such as a sequencer check failure or transaction abort. See the guidelines above for deciding between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE.
	StatusOutOfRange         = codes.OutOfRange         // The operation was attempted past the valid range. E.g., seeking or reading past end-of-file. Unlike INVALID_ARGUMENT, this error indicates a problem that may be fixed if the system state changes. For example, a 32-bit file system will generate INVALID_ARGUMENT if asked to read at an offset that is not in the range [0,2^32-1], but it will generate OUT_OF_RANGE if asked to read from an offset past the current file size. There is a fair bit of overlap between FAILED_PRECONDITION and OUT_OF_RANGE. We recommend using OUT_OF_RANGE (the more specific error) when it applies so that callers who are iterating through a space can easily look for an OUT_OF_RANGE error to detect when they are done.
	StatusUnimplemented      = codes.Unimplemented      // The operation is not implemented or is not supported/enabled in this service.
	StatusInternal           = codes.Internal           // Internal errors. This means that some invariants expected by the underlying system have been broken. This error code is reserved for serious errors.
	StatusUnavailable        = codes.Unavailable        // The service is currently unavailable. This is most likely a transient condition, which can be corrected by retrying with a backoff. Note that it is not always safe to retry non-idempotent operations.
	StatusDataLoss           = codes.DataLoss           // Unrecoverable data loss or corruption.
	StatusUnauthenticated    = codes.Unauthenticated    // The request does not have valid authentication credentials for the operation.

)

Variables

This section is empty.

Functions

func ContextRequestId

func ContextRequestId(ctx context.Context) string

ContextRequestId - return the requestId from a Context

func ContextWithRequest

func ContextWithRequest(req *http.Request) context.Context

ContextWithRequest - creates a new Context with a request id from the request headers

func ContextWithRequestId

func ContextWithRequestId(ctx context.Context, requestId string) context.Context

ContextWithRequestId - creates a new Context with a request id

func Expand

func Expand[T Resolver](t string) (string, error)

func IfElse

func IfElse[T any](cond bool, true T, false T) T

IfElse - implementation of "C" ternary operator : conditional ? [true value] : [false value]

func IsErrors

func IsErrors(errs []error) bool

func IsNil

func IsNil(a any) bool

IsNil - determine if the interface{} holds is nil

Example
package main

import "fmt"

type testStruct struct {
	vers  string
	count int
}

func main() {
	var i any
	var p *int

	fmt.Printf("test: IsNil(nil) -> %v\n", IsNil(nil))
	fmt.Printf("test: IsNil(i) -> %v\n", IsNil(i))
	fmt.Printf("test: IsNil(pi) -> %v\n", IsNil(p))

}
Output:

test: IsNil(nil) -> true
test: IsNil(i) -> true
test: IsNil(pi) -> true

func ReadAll

func ReadAll(body io.ReadCloser) ([]byte, error)

Types

type DebugError

type DebugError struct{}

func (DebugError) Handle

func (h DebugError) Handle(location string, errs ...error) *Status

func (DebugError) HandleStatus

func (h DebugError) HandleStatus(s *Status) *Status

func (DebugError) HandleWithContext

func (h DebugError) HandleWithContext(ctx context.Context, location string, errs ...error) *Status

type ErrorHandleFn

type ErrorHandleFn func(location string, errs ...error) *Status
Example
loc := pkgPath + "/ErrorHandleFn"
err := errors.New("debug - error message")

fn := NewErrorHandleFn[DebugError]()
fn(loc, err)
fmt.Printf("test: NewErrorHandleFn[DebugErrorHandler]()\n")

fn = NewErrorHandleFn[LogError]()
fn(loc, errors.New("log - error message"))
fmt.Printf("test: NewErrorHandleFn[LogErrorHandler]()\n")
Output:

[[] github.com/idiomatic-go/middleware/template/ErrorHandleFn [debug - error message]]
test: NewErrorHandleFn[DebugErrorHandler]()
test: NewErrorHandleFn[LogErrorHandler]()

func NewErrorHandleFn

func NewErrorHandleFn[E ErrorHandler]() ErrorHandleFn

type ErrorHandler

type ErrorHandler interface {
	Handle(location string, errs ...error) *Status
	HandleWithContext(ctx context.Context, location string, errs ...error) *Status
	HandleStatus(s *Status) *Status
}

type ErrorStatusHandleFn

type ErrorStatusHandleFn func(s *Status) *Status

func NewErrorStatusHandleFn

func NewErrorStatusHandleFn[E ErrorHandler]() ErrorStatusHandleFn

type Location

type Location string

type LogError

type LogError struct{}

func (LogError) Handle

func (h LogError) Handle(location string, errs ...error) *Status

func (LogError) HandleStatus

func (h LogError) HandleStatus(s *Status) *Status

func (LogError) HandleWithContext

func (h LogError) HandleWithContext(ctx context.Context, location string, errs ...error) *Status

type LogOutput

type LogOutput struct{}

func (LogOutput) Write

func (LogOutput) Write(s string)

type NilOutput

type NilOutput struct{}

func (NilOutput) Write

func (NilOutput) Write(s string)

type NoOpError

type NoOpError struct{}

func (NoOpError) Handle

func (NoOpError) Handle(location string, errs ...error) *Status

func (NoOpError) HandleStatus

func (NoOpError) HandleStatus(s *Status) *Status

func (NoOpError) HandleWithContext

func (NoOpError) HandleWithContext(ctx context.Context, location string, errs ...error) *Status

type OutputHandler

type OutputHandler interface {
	Write(s string)
}
Example
fmt.Printf("test: Output[NilOutputHandler](s)\n")
Output[NilOutput]("nil output handler")

fmt.Printf("test: Output[StdOutputHandler](s)\n")
Output[StdOutput]("std output handler")

fmt.Printf("test: Output[TestOutputHandler](s)\n")
Output[TestOutput]("test output handler")

fmt.Printf("test: Output[LogOutputHandler](s)\n")
Output[LogOutput]("log output handler")
Output:

test: Output[NilOutputHandler](s)
test: Output[StdOutputHandler](s)
std output handler
test: Output[TestOutputHandler](s)
test: Write() -> [test output handler]
test: Output[LogOutputHandler](s)

type Resolver

type Resolver interface {
	Lookup(name string) (string, error)
}

type Status

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

func Deserialize

func Deserialize[T any](body io.ReadCloser) (T, *Status)
Example
result, status := Deserialize[[]byte](nil)
fmt.Printf("test: Deserialize[[]byte](nil) -> [%v] [status:%v]\n", string(result), status)

resp := new(http.Response)
result, status = Deserialize[[]byte](resp.Body)
fmt.Printf("test: Deserialize[[]byte](resp) -> [%v] [status:%v]\n", string(result), status)

resp.Body = &httptest.ReaderCloser{Reader: strings.NewReader("Hello World String"), Err: nil}
result, status = Deserialize[[]byte](resp.Body)
fmt.Printf("test: Deserialize[[]byte](resp) -> [%v] [status:%v]\n", string(result), status)

resp.Body = &httptest.ReaderCloser{Reader: bytes.NewReader([]byte("Hello World []byte")), Err: nil}
result2, status2 := Deserialize[[]byte](resp.Body)
fmt.Printf("test: Deserialize[[]byte](resp) -> [%v] [status:%v]\n", string(result2), status2)
Output:

test: Deserialize[[]byte](nil) -> [] [status:Invalid Content [body is nil]]
test: Deserialize[[]byte](resp) -> [] [status:Invalid Content [body is nil]]
test: Deserialize[[]byte](resp) -> [Hello World String] [status:OK]
test: Deserialize[[]byte](resp) -> [Hello World []byte] [status:OK]

func NewHttpStatus

func NewHttpStatus(resp *http.Response, location string, errs ...error) *Status

func NewHttpStatusCode

func NewHttpStatusCode(code int) *Status

func NewStatus

func NewStatus(code codes.Code, location string, errs ...error) *Status

func NewStatusCode

func NewStatusCode(code codes.Code) *Status

func NewStatusError

func NewStatusError(location string, errs ...error) *Status

func NewStatusInvalidArgument

func NewStatusInvalidArgument(location string, err error) *Status

func NewStatusOK

func NewStatusOK() *Status

func NewStatusWithContext

func NewStatusWithContext(code codes.Code, location string, ctx context.Context, errs ...error) *Status

func (*Status) AddMetadata

func (s *Status) AddMetadata(h http.Header, keys ...string)
Example
s := NewStatusOK()

s.SetMetadata("content-type", "text/plain", "content-length", "1234", "host", "www.google.com")
h := make(http.Header)
s.AddMetadata(h, "content-length", "host")
fmt.Printf("test: AddMetadata(h) -> %v\n", h)
Output:

test: AddMetadata(h) -> map[Content-Length:[1234] Host:[www.google.com]]

func (*Status) Code

func (s *Status) Code() codes.Code

func (*Status) Content

func (s *Status) Content() []byte

func (*Status) Description

func (s *Status) Description() string

func (*Status) Duration

func (s *Status) Duration() time.Duration

func (*Status) Errors

func (s *Status) Errors() []error

func (*Status) Http

func (s *Status) Http() int
Example
location := "test"
err := errors.New("http error")
fmt.Printf("test: NewHttpStatus(nil) -> [%v]\n", NewHttpStatus(nil, location, nil))
fmt.Printf("test: NewHttpStatus(nil) -> [%v]\n", NewHttpStatus(nil, location, err))

resp := http.Response{StatusCode: http.StatusBadRequest}
fmt.Printf("test: NewHttpStatus(resp) -> [%v]\n", NewHttpStatus(&resp, location, nil))
fmt.Printf("test: NewHttpStatus(resp) -> [%v]\n", NewHttpStatus(&resp, location, err))
Output:

test: NewHttpStatus(nil) -> [Invalid Content]
test: NewHttpStatus(nil) -> [Internal Error [http error]]
test: NewHttpStatus(resp) -> [Bad Request]
test: NewHttpStatus(resp) -> [Internal Error [http error]]

func (*Status) Internal

func (s *Status) Internal() bool

func (*Status) InvalidArgument

func (s *Status) InvalidArgument() bool

func (*Status) IsContent

func (s *Status) IsContent() bool

func (*Status) IsErrors

func (s *Status) IsErrors() bool

func (*Status) IsGRPCCode

func (s *Status) IsGRPCCode() bool

func (*Status) Location

func (s *Status) Location() string

func (*Status) NotFound

func (s *Status) NotFound() bool

func (*Status) OK

func (s *Status) OK() bool

func (*Status) PermissionDenied

func (s *Status) PermissionDenied() bool

func (*Status) ServiceUnavailable

func (s *Status) ServiceUnavailable() bool

func (*Status) SetCode

func (s *Status) SetCode(code codes.Code) *Status

func (*Status) SetContent

func (s *Status) SetContent(content []byte, vals ...string) *Status

func (*Status) SetContext

func (s *Status) SetContext(ctx context.Context) *Status

func (*Status) SetDuration

func (s *Status) SetDuration(duration time.Duration) *Status

func (*Status) SetMetadata

func (s *Status) SetMetadata(kv ...string)
Example
s := NewStatusOK()

s.SetMetadata("content-type", "text/plain")
fmt.Printf("test: SetMetadata() -> %v\n", s.md)

s = NewStatusOK()
resp := &http.Response{}
resp.Header = make(http.Header)
resp.Header.Add("content-length", "1234")
resp.Header.Add("host", "www.google.com")
s.SetMetadataFromResponse(resp, "host", "content-length")
fmt.Printf("test: SetMetadata() -> %v\n", s.md)
Output:

test: SetMetadata() -> map[content-type:[text/plain]]
test: SetMetadata() -> map[content-length:[1234] host:[www.google.com]]

func (*Status) SetMetadataFromResponse

func (s *Status) SetMetadataFromResponse(resp *http.Response, keys ...string)

func (*Status) String

func (s *Status) String() string
Example
s := NewStatus(StatusPermissionDenied, "", nil)
fmt.Printf("test: NewStatus() -> [%v]\n", s)

s = NewStatus(StatusOutOfRange, "", errors.New("error - 1"), errors.New("error - 2"))
fmt.Printf("test: NewStatus() -> [%v]\n", s)
Output:

test: NewStatus() -> [OK]
test: NewStatus() -> [OutOfRange [error - 1 error - 2]]

func (*Status) Timeout

func (s *Status) Timeout() bool

func (*Status) Unauthenticated

func (s *Status) Unauthenticated() bool

type StdOutput

type StdOutput struct{}

func (StdOutput) Write

func (StdOutput) Write(s string)

type TestOutput

type TestOutput struct{}

func (TestOutput) Write

func (TestOutput) Write(s string)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL