runtime

package
v0.0.0-...-755224a Latest Latest
Warning

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

 Go to latest Published: Jun 15, 2023 License: BSD-3-Clause Imports: 17 Imported by: 7

Documentation

Index

Examples

Constants

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 (
	EnvPrefix = "$"
)
View Source 
const (
	NilDuration = time.Duration(-1)
)

Variables

View Source 
var PkgUrl = reflect.TypeOf(any(pkg{})).PkgPath()

Functions

func ContextRequestId 

func ContextRequestId(ctx any) string

ContextRequestId - return the requestId from a context

func ContextWithProxy 

func ContextWithProxy(ctx context.Context, proxy any) context.Context

ContextWithProxy - create a new Context interface, containing a proxy

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 a Proxy context

func Expand 

func Expand(fn func(string) (string, error), t string) (string, error)

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

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

}

Output:

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

func IsProxyable 

func IsProxyable(ctx context.Context) ([]any, bool)

IsProxyable - determine if the context is a ProxyContext, and return proxies

func LookupEnv 

func LookupEnv(name string) (string, error)
Example 
name := ""

s, err := LookupEnv(name)
fmt.Printf("test: LookupEnv(%v) -> [err:%v][%v]\n", name, err, s)

s, err = LookupEnv("$")
fmt.Printf("test: LookupEnv(%v) -> [err:%v][%v]\n", name, err, s)

os.Setenv("RUNTIME", "DEV")
s, err = LookupEnv("$RUNTIME")
fmt.Printf("test: LookupEnv(%v) -> [err:%v][%v]\n", name, err, s)

Output:

test: LookupEnv() -> [err:invalid argument : template variable is invalid: ][]
test: LookupEnv() -> [err:<nil>][]
test: LookupEnv() -> [err:<nil>][DEV]

func TextToList 

func TextToList(buf []byte) []string

TextToList - create a slice from a []byte

func TextToMap 

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

TextToMap - create a map from a []byte

func TrimSpace 

func TrimSpace(s string) string

func ValidateMap 

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

ValidateMap - 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 := ValidateMap(nil, nil)
fmt.Printf("test: ValidateConfig(nil,nil) -> %v\n", errs)

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

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

errs = ValidateMap(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 Attr 

type Attr struct {
	Key string
	Val any
}

type DebugError 

type DebugError struct{}

DebugError - debug error handler

func (DebugError) Handle 

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

func (DebugError) HandleStatus 

func (h DebugError) HandleStatus(_ any, s *Status) *Status

type ErrorHandleFn 

type ErrorHandleFn func(ctx any, location string, errs ...error) *Status

ErrorHandleFn - function type for error handling

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

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

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

Output:

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

func NewErrorHandler 

func NewErrorHandler[E ErrorHandler]() ErrorHandleFn

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

type ErrorHandler 

type ErrorHandler interface {
	Handle(ctx any, location string, errs ...error) *Status
}

ErrorHandler - template parameter error handler interface

type LogError 

type LogError struct{}

LogError - debug error handler

func (LogError) Handle 

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

func (LogError) HandleStatus 

func (h LogError) HandleStatus(_ any, s *Status) *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 Origin 

type Origin struct {
	Region     string
	Zone       string
	SubZone    string
	Service    string
	InstanceId string
}

Origin - struct for origin information

func NewOrigin 

func NewOrigin(s string) *Origin

func (*Origin) String 

func (o *Origin) String() string

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

func (s *Status) SetRequestId(requestId 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)

type TextPair 

type TextPair struct {
	Key   string
	Value string
}

func ListToTextPair 

func ListToTextPair(s []string) []TextPair
Example 
s := []string{"key", "key1,value1", "key2,value2"}
pair := ListToTextPair(s)
fmt.Printf("test: ListToTextPari() -> %v", pair)

Output:

test: ListToTextPari() -> [{key } {key1 value1} {key2 value2}]

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.