runtime

package
v0.0.0-...-9a998da Latest Latest
Warning

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

 Go to latest Published: Mar 10, 2023 License: BSD-3-Clause Imports: 17 Imported by: 1

Documentation

Index

Examples

Constants

View Source 
const (
	DevEnv = iota
	ReviewEnv
	TestEnv
	StageEnv
	ProdEnv

	DevEnvValue    = "dev"
	ReviewEnvValue = "review"
	TestEnvValue   = "test"
	StageEnvValue  = "stage"
	ProdEnvValue   = "prod"
)
View Source 
const (
	BeginDelimiter = "{"
	EndDelimiter   = "}"
)
View Source 
const (
	ContentTypeText = "text/plain" // charset=utf-8
	ContentTypeJson = "application/json"
)
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.

)
View Source 
const (
	EnvVariableReference = "{env}"
)
View Source 
const (
	NilDuration = time.Duration(-1)
)

Variables

This section is empty.

Functions

func ContextRequestId 

func ContextRequestId(ctx context.Context) string

ContextRequestId - return the requestId from a Context

func ContextWithHttpExchange 

func ContextWithHttpExchange(ctx context.Context, do func(*http.Request) (*http.Response, error)) context.Context

ContextWithHttpExchange - create a new Context interface, containing a Http exchange function

func ContextWithRequest 

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

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

Example 
ctx := ContextWithRequestId(context.Background(), "123-456-abc")
fmt.Printf("test: ContextWithRequestId(ctx,id) -> %v\n", ContextRequestId(ctx))

ctx = ContextWithRequest(nil)
fmt.Printf("test: ContextWithRequest(nil) -> %v\n", ContextRequestId(ctx) != "")

req, _ := http.NewRequest("", "https.www.google.com", nil)
ctx = ContextWithRequest(req)
fmt.Printf("test: ContextWithRequest(req) -> %v\n", ContextRequestId(ctx) != "")

req, _ = http.NewRequest("", "https.www.google.com", nil)
req.Header.Add(xRequestIdName, "x-request-id-value")
ctx = ContextWithRequest(req)
fmt.Printf("test: ContextWithRequest(req) -> %v\n", ContextRequestId(ctx))

Output:

test: ContextWithRequestId(ctx,id) -> 123-456-abc
test: ContextWithRequest(nil) -> false
test: ContextWithRequest(req) -> true
test: ContextWithRequest(req) -> x-request-id-value

func ContextWithRequestId 

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

ContextWithRequestId - creates a new Context with a request id

func ContextWithValue 

func ContextWithValue(ctx context.Context, key any, val any) context.Context

ContextWithValue - create a new context with a value, updating the context if it is an HttpExchange context

func EnvExpansion 

func EnvExpansion(s string) string

EnvExpansion - expand a template with an environment variable reference

func Expand 

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

Expand - templated function to expand a template string, utilizing a resolver

Example 
package main

import (
	"fmt"
	"github.com/idiomatic-go/motif/runtime"
)

func main() {
	runtime.SetRuntimeEnv("dev")

	t := "file_{env}.txt"
	fmt.Printf("test: EnvExpansion(%v) -> %v\n", t, runtime.EnvExpansion(t))

	runtime.SetRuntimeEnv("prod")
	fmt.Printf("test: EnvExpansion(%v) -> %v\n", t, runtime.EnvExpansion(t))

	t = "file_{env_var_invalid}.txt"
	fmt.Printf("test: EnvExpansion(%v) -> %v\n", t, runtime.EnvExpansion(t))

}

Output:

test: EnvExpansion(file_{env}.txt) -> file_dev.txt
test: EnvExpansion(file_{env}.txt) -> file_prod.txt
test: EnvExpansion(file_{env_var_invalid}.txt) -> invalid or missing environment variable reference: {env}

func GetRuntimeEnv 

func GetRuntimeEnv() string

GetRuntimeEnv - function to get the runtime environment

func IfElse 

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

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

func IsDevEnv 

func IsDevEnv() bool

IsDevEnv - determine environment

func IsErrors 

func IsErrors(errs []error) bool

IsErrors - determine if there are errors in an []error

func IsNil 

func IsNil(a any) bool

IsNil - determine if the interface{} is nil, or if it holds a nil pointer

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 IsProdEnv 

func IsProdEnv() bool

func IsReviewEnv 

func IsReviewEnv() bool

func IsStageEnv 

func IsStageEnv() bool

func IsTestEnv 

func IsTestEnv() bool

func ParseMap 

func ParseMap(buf []byte) (map[string]string, error)

ParseMap - create a map from a []byte

func SetRuntimeEnv 

func SetRuntimeEnv(s string)

SetRuntimeEnv - function to set the runtime environment

func ValidateConfig 

func ValidateConfig(m map[string]string, err error, keys ...string) (errs []error)

ValidateConfig - validates a configuration map, iterating through all keys

Example 
m := map[string]string{"database-url": "postgres://{user}:{pswd}@{sub-domain}.{db-name}.cloud.timescale.com:31770/tsdb?sslmode=require", "ping-path": "", "postgres-urn": "urn:postgres", "postgres-pgxsql-uri": "github.com/idiomatic-go/postgresql/pgxsql"}
errs := ValidateConfig(nil, nil)
fmt.Printf("test: ValidateConfig(nil,nil) -> %v\n", errs)

errs = ValidateConfig(m, errors.New("file I/O error"))
fmt.Printf("test: ValidateConfig(m,err) -> %v\n", errs)

errs = ValidateConfig(m, nil, "not-found")
fmt.Printf("test: Validate(m,nil,not-found) -> %v\n", errs)

errs = ValidateConfig(m, nil, "database-url", "ping-path", "postgres-pgxsql-uri")
fmt.Printf("test: Validate(m,nil,...) -> %v\n", errs)

Output:

test: ValidateConfig(nil,nil) -> [config map is nil]
test: ValidateConfig(m,err) -> [config map read error: file I/O error]
test: Validate(m,nil,not-found) -> [[config map error: key does not exist [not-found]]
test: Validate(m,nil,...) -> [config map error: value for key does not exist [ping-path]]

Types

type DebugError 

type DebugError struct{}

DebugError - debug error handler

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

ErrorHandleFn - function type for error handling

Example 
loc := pkgPath + "/ErrorHandleFn"
err := errors.New("debug - error message")

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

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

Output:

[[] github.com/idiomatic-go/motif/runtime/ErrorHandleFn [debug - error message]]
test: Handle[DebugErrorHandler]()
test: Handle[LogErrorHandler]()

func Handle 

func Handle[E ErrorHandler]() ErrorHandleFn

Handle - templated function providing an error handle function via a closure

type ErrorHandleWithContextFn 

type ErrorHandleWithContextFn func(ctx context.Context, location string, errs ...error) *Status

ErrorHandleWithContextFn - function type for error handling with context

func HandleWithContext 

func HandleWithContext[E ErrorHandler]() ErrorHandleWithContextFn

HandleWithContext - templated function providing an error handle function with context via a closure

type ErrorHandler 

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

ErrorHandler - template parameter error handler interface

type ErrorStatusHandleFn 

type ErrorStatusHandleFn func(s *Status) *Status

ErrorStatusHandleFn - function type for error status handling

func StatusHandle 

func StatusHandle[E ErrorHandler]() ErrorStatusHandleFn

StatusHandle - templated function providing an error status handle function via a closure

type LogError 

type LogError struct{}

LogError - logging error handler

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{}

NoOpError - no operation on errors

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

OutputHandler - template parameter output handler interface

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

Resolver - template parameter name value lookup

type Status 

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

Status - struct for status data

func NewHttpStatus 

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

NewHttpStatus - new Status from a http.Response, location, and optional errors

func NewHttpStatusCode 

func NewHttpStatusCode(code int) *Status

NewHttpStatusCode - new Status from a http status code

func NewStatus 

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

NewStatus - new Status from a code, location, and optional errors

func NewStatusCode 

func NewStatusCode(code codes.Code) *Status

NewStatusCode - new Status from a code

func NewStatusError 

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

NewStatusError - new Internal status with location and errors

func NewStatusInvalidArgument 

func NewStatusInvalidArgument(location string, err error) *Status

func NewStatusOK 

func NewStatusOK() *Status

NewStatusOK - new OK 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) *Status
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
Example 
str := "test string content"
s := NewStatusOK()

s.SetContent(str)
fmt.Printf("test: SetContent(%v) -> [content:%v] [type:%v]\n", str, string(s.Content()), s.MetadataValue(headers.ContentType))

s.RemoveContent()
s.SetContent([]byte(str))
fmt.Printf("test: SetContent(%v) -> [content:%v] [type:%v]\n", str, string(s.Content()), s.MetadataValue(headers.ContentType))

s.RemoveContent()
s.SetContent(12345)
fmt.Printf("test: SetContent(12345) -> [content:%v] [type:%v]\n", string(s.Content()), s.MetadataValue(headers.ContentType))

s.RemoveContent()
s.SetContent(address{
	Street: "123 Oak Street",
	City:   "Anytown",
	State:  "USA",
	Zip:    "01234",
})

fmt.Printf("test: SetContent(address) -> [content:%v] [type:%v]\n", string(s.Content()), s.MetadataValue(headers.ContentType))

s.RemoveContent()
str = "error message"
s.SetContent(errors.New(str))
fmt.Printf("test: SetContent(%v) -> [content:%v] [type:%v]\n", str, string(s.Content()), s.MetadataValue(headers.ContentType))

Output:

test: SetContent(test string content) -> [content:test string content] [type:text/plain]
test: SetContent(test string content) -> [content:test string content] [type:application/json]
test: SetContent(12345) -> [content:12345] [type:application/json]
test: SetContent(address) -> [content:{"Street":"123 Oak Street","City":"Anytown","State":"USA","Zip":"01234"}] [type:application/json]
test: SetContent(error message) -> [content:error message] [type:text/plain]

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

func (s *Status) MetadataValue(key string) 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) RemoveContent 

func (s *Status) RemoveContent()

func (*Status) RemoveErrors 

func (s *Status) RemoveErrors()

func (*Status) RequestId 

func (s *Status) RequestId() string

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 any, 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) *Status
Example 
s := NewStatusOK()

s.SetMetadata("content-type", "text/plain", "content-length")
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-length:[] 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) *Status

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.