runtime

package
v0.0.0-...-d88c8b5 Latest Latest
Warning

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

 Go to latest Published: Feb 9, 2021 License: Apache-2.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// HeaderContentType represents a http content-type header, it's value is supposed to be a mime type
	HeaderContentType = "Content-Type"

	// HeaderTransferEncoding represents a http transfer-encoding header.
	HeaderTransferEncoding = "Transfer-Encoding"

	// HeaderAccept the Accept header
	HeaderAccept = "Accept"

	// DefaultMime the default fallback mime type
	DefaultMime = "application/octet-stream"
	// JSONMime the json mime type
	JSONMime = "application/json"
	// YAMLMime the yaml mime type
	YAMLMime = "application/x-yaml"
	// XMLMime the xml mime type
	XMLMime = "application/xml"
	// TextMime the text mime type
	TextMime = "text/plain"
	// HTMLMime the html mime type
	HTMLMime = "text/html"
	// CSVMime the csv mime type
	CSVMime = "text/csv"
	// MultipartFormMime the multipart form mime type
	MultipartFormMime = "multipart/form-data"
	// URLencodedFormMime the url encoded form mime type
	URLencodedFormMime = "application/x-www-form-urlencoded"
)

Variables

View Source 
var DiscardConsumer = ConsumerFunc(func(_ io.Reader, _ interface{}) error { return nil })

DiscardConsumer does absolutely nothing, it's a black hole.

View Source 
var DiscardProducer = ProducerFunc(func(_ io.Writer, _ interface{}) error { return nil })

DiscardProducer does absolutely nothing, it's a black hole.

View Source 
var Statuses = map[int]string{
	100: "Continue",
	101: "Switching Protocols",
	102: "Processing",
	103: "Checkpoint",
	122: "URI too long",
	200: "OK",
	201: "Created",
	202: "Accepted",
	203: "Request Processed",
	204: "No Content",
	205: "Reset Content",
	206: "Partial Content",
	207: "Multi-Status",
	208: "Already Reported",
	226: "IM Used",
	300: "Multiple Choices",
	301: "Moved Permanently",
	302: "Found",
	303: "See Other",
	304: "Not Modified",
	305: "Use Proxy",
	306: "Switch Proxy",
	307: "Temporary Redirect",
	308: "Permanent Redirect",
	400: "Bad Request",
	401: "Unauthorized",
	402: "Payment Required",
	403: "Forbidden",
	404: "Not Found",
	405: "Method Not Allowed",
	406: "Not Acceptable",
	407: "Proxy Authentication Required",
	408: "Request Timeout",
	409: "Conflict",
	410: "Gone",
	411: "Length Required",
	412: "Precondition Failed",
	413: "Request Entity Too Large",
	414: "Request-URI Too Long",
	415: "Unsupported Media Type",
	416: "Request Range Not Satisfiable",
	417: "Expectation Failed",
	418: "I'm a teapot",
	420: "Enhance Your Calm",
	422: "Unprocessable Entity",
	423: "Locked",
	424: "Failed Dependency",
	426: "Upgrade Required",
	428: "Precondition Required",
	429: "Too Many Requests",
	431: "Request Header Fields Too Large",
	444: "No Response",
	449: "Retry With",
	450: "Blocked by Windows Parental Controls",
	451: "Wrong Exchange Server",
	499: "Client Closed Request",
	500: "Internal Server Error",
	501: "Not Implemented",
	502: "Bad Gateway",
	503: "Service Unavailable",
	504: "Gateway Timeout",
	505: "HTTP Version Not Supported",
	506: "Variant Also Negotiates",
	507: "Insufficient Storage",
	508: "Loop Detected",
	509: "Bandwidth Limit Exceeded",
	510: "Not Extended",
	511: "Network Authentication Required",
	598: "Network read timeout error",
	599: "Network connect timeout error",
}

Statuses lists the most common HTTP status codes to default message taken from https://httpstatuses.com/

Functions

func AllowsBody 

func AllowsBody(r *http.Request) bool

AllowsBody returns true if the request allows for a body

func CanHaveBody 

func CanHaveBody(method string) bool

CanHaveBody returns true if this method can have a body

func ClosesStream 

func ClosesStream(opts *byteStreamOpts)

ClosesStream when the bytestream consumer or producer is finished

func ContentType 

func ContentType(headers http.Header) (string, string, error)

ContentType parses a content type header

func HasBody 

func HasBody(r *http.Request) bool

HasBody returns true if this method needs a content-type

func IsSafe 

func IsSafe(r *http.Request) bool

IsSafe returns true if this is a request with a safe method

func JSONRequest 

func JSONRequest(method, urlStr string, body io.Reader) (*http.Request, error)

JSONRequest creates a new http request with json headers set

func ReadCollectionValue 

func ReadCollectionValue(values Gettable, name, collectionFormat string) []string

ReadCollectionValue reads a collection value from a string data source

func ReadSingleValue 

func ReadSingleValue(values Gettable, name string) string

ReadSingleValue reads a single value from the source

Types

type APIError 

type APIError struct {
	OperationName string
	Response      interface{}
	Code          int
}

APIError wraps an error model and captures the status code

func NewAPIError 

func NewAPIError(opName string, payload interface{}, code int) *APIError

NewAPIError creates a new API error

func (*APIError) Error 

func (a *APIError) Error() string

type Authenticator 

type Authenticator interface {
	Authenticate(interface{}) (bool, interface{}, error)
}

Authenticator represents an authentication strategy implementations of Authenticator know how to authenticate the request data and translate that into a valid principal object or an error

type AuthenticatorFunc 

type AuthenticatorFunc func(interface{}) (bool, interface{}, error)

AuthenticatorFunc turns a function into an authenticator

func (AuthenticatorFunc) Authenticate 

func (f AuthenticatorFunc) Authenticate(params interface{}) (bool, interface{}, error)

Authenticate authenticates the request with the provided data

type Authorizer 

type Authorizer interface {
	Authorize(*http.Request, interface{}) error
}

Authorizer represents an authorization strategy implementations of Authorizer know how to authorize the principal object using the request data and returns error if unauthorized

type AuthorizerFunc 

type AuthorizerFunc func(*http.Request, interface{}) error

AuthorizerFunc turns a function into an authorizer

func (AuthorizerFunc) Authorize 

func (f AuthorizerFunc) Authorize(r *http.Request, principal interface{}) error

Authorize authorizes the processing of the request for the principal

type ClientAuthInfoWriter 

type ClientAuthInfoWriter interface {
	AuthenticateRequest(ClientRequest, strfmt.Registry) error
}

A ClientAuthInfoWriter implementor knows how to write authentication info to a request

type ClientAuthInfoWriterFunc 

type ClientAuthInfoWriterFunc func(ClientRequest, strfmt.Registry) error

A ClientAuthInfoWriterFunc converts a function to a request writer interface

func (ClientAuthInfoWriterFunc) AuthenticateRequest 

func (fn ClientAuthInfoWriterFunc) AuthenticateRequest(req ClientRequest, reg strfmt.Registry) error

AuthenticateRequest adds authentication data to the request

type ClientOperation 

type ClientOperation struct {
	ID                 string
	Method             string
	PathPattern        string
	ProducesMediaTypes []string
	ConsumesMediaTypes []string
	Schemes            []string
	AuthInfo           ClientAuthInfoWriter
	Params             ClientRequestWriter
	Reader             ClientResponseReader
	Context            context.Context
	Client             *http.Client
}

ClientOperation represents the context for a swagger operation to be submitted to the transport

type ClientRequest 

type ClientRequest interface {
	SetHeaderParam(string, ...string) error

	GetHeaderParams() http.Header

	SetQueryParam(string, ...string) error

	SetFormParam(string, ...string) error

	SetPathParam(string, string) error

	GetQueryParams() url.Values

	SetFileParam(string, ...NamedReadCloser) error

	SetBodyParam(interface{}) error

	SetTimeout(time.Duration) error

	GetMethod() string

	GetPath() string

	GetBody() []byte

	GetBodyParam() interface{}

	GetFileParam() map[string][]NamedReadCloser
}

ClientRequest is an interface for things that know how to add information to a swagger client request

type ClientRequestWriter 

type ClientRequestWriter interface {
	WriteToRequest(ClientRequest, strfmt.Registry) error
}

ClientRequestWriter is an interface for things that know how to write to a request

type ClientRequestWriterFunc 

type ClientRequestWriterFunc func(ClientRequest, strfmt.Registry) error

ClientRequestWriterFunc converts a function to a request writer interface

func (ClientRequestWriterFunc) WriteToRequest 

func (fn ClientRequestWriterFunc) WriteToRequest(req ClientRequest, reg strfmt.Registry) error

WriteToRequest adds data to the request

type ClientResponse 

type ClientResponse interface {
	Code() int
	Message() string
	GetHeader(string) string
	Body() io.ReadCloser
}

A ClientResponse represents a client response This bridges between responses obtained from different transports

type ClientResponseReader 

type ClientResponseReader interface {
	ReadResponse(ClientResponse, Consumer) (interface{}, error)
}

A ClientResponseReader is an interface for things want to read a response. An application of this is to create structs from response values

type ClientResponseReaderFunc 

type ClientResponseReaderFunc func(ClientResponse, Consumer) (interface{}, error)

A ClientResponseReaderFunc turns a function into a ClientResponseReader interface implementation

func (ClientResponseReaderFunc) ReadResponse 

func (read ClientResponseReaderFunc) ReadResponse(resp ClientResponse, consumer Consumer) (interface{}, error)

ReadResponse reads the response

type ClientTransport 

type ClientTransport interface {
	//Submit(string, RequestWriter, ResponseReader, AuthInfoWriter) (interface{}, error)
	Submit(*ClientOperation) (interface{}, error)
}

A ClientTransport implementor knows how to submit Request objects to some destination

type Consumer 

type Consumer interface {
	// Consume performs the binding of request values
	Consume(io.Reader, interface{}) error
}

Consumer implementations know how to bind the values on the provided interface to data provided by the request body

func ByteStreamConsumer 

func ByteStreamConsumer(opts ...byteStreamOpt) Consumer

ByteStreamConsumer creates a consmer for byte streams, takes a Writer/BinaryUnmarshaler interface or binary slice by reference, and reads from the provided reader

func CSVConsumer 

func CSVConsumer() Consumer

CSVConsumer creates a new CSV consumer

func JSONConsumer 

func JSONConsumer() Consumer

JSONConsumer creates a new JSON consumer

func TextConsumer 

func TextConsumer() Consumer

TextConsumer creates a new text consumer

func XMLConsumer 

func XMLConsumer() Consumer

XMLConsumer creates a new XML consumer

type ConsumerFunc 

type ConsumerFunc func(io.Reader, interface{}) error

ConsumerFunc represents a function that can be used as a consumer

func (ConsumerFunc) Consume 

func (fn ConsumerFunc) Consume(reader io.Reader, data interface{}) error

Consume consumes the reader into the data parameter

type File 

type File struct {
	Data   multipart.File
	Header *multipart.FileHeader
}

File represents an uploaded file.

func (*File) Close 

func (f *File) Close() error

Close the file

func (*File) Read 

func (f *File) Read(p []byte) (n int, err error)

Read bytes from the file

type Gettable 

type Gettable interface {
	GetOK(string) ([]string, bool, bool)
}

Gettable for things with a method GetOK(string) (data string, hasKey bool, hasValue bool)

type NamedReadCloser 

type NamedReadCloser interface {
	io.ReadCloser
	Name() string
}

NamedReadCloser represents a named ReadCloser interface

func NamedReader 

func NamedReader(name string, rdr io.Reader) NamedReadCloser

NamedReader creates a NamedReadCloser for use as file upload

type OperationHandler 

type OperationHandler interface {
	Handle(interface{}) (interface{}, error)
}

OperationHandler a handler for a swagger operation

type OperationHandlerFunc 

type OperationHandlerFunc func(interface{}) (interface{}, error)

OperationHandlerFunc an adapter for a function to the OperationHandler interface

func (OperationHandlerFunc) Handle 

func (s OperationHandlerFunc) Handle(data interface{}) (interface{}, error)

Handle implements the operation handler interface

type Producer 

type Producer interface {
	// Produce writes to the http response
	Produce(io.Writer, interface{}) error
}

Producer implementations know how to turn the provided interface into a valid HTTP response

func ByteStreamProducer 

func ByteStreamProducer(opts ...byteStreamOpt) Producer

ByteStreamProducer creates a producer for byte streams, takes a Reader/BinaryMarshaler interface or binary slice, and writes to a writer (essentially a pipe)

func CSVProducer 

func CSVProducer() Producer

CSVProducer creates a new CSV producer

func JSONProducer 

func JSONProducer() Producer

JSONProducer creates a new JSON producer

func TextProducer 

func TextProducer() Producer

TextProducer creates a new text producer

func XMLProducer 

func XMLProducer() Producer

XMLProducer creates a new XML producer

type ProducerFunc 

type ProducerFunc func(io.Writer, interface{}) error

ProducerFunc represents a function that can be used as a producer

func (ProducerFunc) Produce 

func (f ProducerFunc) Produce(writer io.Writer, data interface{}) error

Produce produces the response for the provided data

type Validatable 

type Validatable interface {
	Validate(strfmt.Registry) error
}

Validatable types implementing this interface allow customizing their validation this will be used instead of the reflective validation based on the spec document. the implementations are assumed to have been generated by the swagger tool so they should contain all the validations obtained from the spec

type Values 

type Values map[string][]string

Values typically represent parameters on a http request.

func (Values) GetOK 

func (v Values) GetOK(key string) (value []string, hasKey bool, hasValue bool)

GetOK returns the values collection for the given key. When the key is present in the map it will return true for hasKey. When the value is not empty it will return true for hasValue.

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.