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))

}

/*
func ExampleIsPointer() {
	var i any
	var s string
	var data = testStruct{}
	var count int
	var bytes []byte

	fmt.Printf("any : %v\n", IsPointer(i))
	fmt.Printf("int : %v\n", IsPointer(count))
	fmt.Printf("int * : %v\n", IsPointer(&count))
	fmt.Printf("string : %v\n", IsPointer(s))
	fmt.Printf("string * : %v\n", IsPointer(&s))
	fmt.Printf("struct : %v\n", IsPointer(data))
	fmt.Printf("struct * : %v\n", IsPointer(&data))
	fmt.Printf("[]byte : %v\n", IsPointer(bytes))
	//fmt.Printf("Struct * : %v\n", IsPointer(&data))

	//Output:
	// any : false
	// int : false
	// int * : true
	// string : false
	// string * : true
	// struct : false
	// struct * : true
	// []byte : false

}


*/

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)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.