granitic: github.com/graniticio/granitic/ws Index | Files | Directories

package ws

import "github.com/graniticio/granitic/ws"

Package ws defines types used by framework and application components involved in web service processing. For more information on how web services work in Granitic, see http://granitic.io/1.0/ref/web-services

A brief explanation of the key types and concepts follows.

Requests and responses

WsRequest and WsResponse are abstractions of the HTTP request and response associated with a call to a web service endpoint. By default your application logic will not have access to the underlying HTTP objects (this can be overridden on a per-endpoint basis by setting AllowDirectHTTPAccess to true on your handler - see the package documentation for ws/handler for more information).

Your application code will not directly control how data is parsed into a WsRequest or how the data and/or errors in a WsResponse are rendered to the caller. This is instead handled by the JsonWs or XmlWs facility.

HTTP status codes are determined automatically based on the type (or lack of) errors in the WsResponse object, but this behaviour can be overridden by setting an HTTP status code manually on the WsResponse.

Errors

Errors can be detected or occur during all the phases of request processing (see http://granitic.io/1.0/ref/request-processing-phases). If errors are encountered during the parsing and binding phases of request processing, they are referred to as 'framework errors' as they are handled outside of application code. Framework errors result in one of small number of generic error messages being sent to a caller. See http://granitic.io/1.0/ref/errors-and-messages for information on how to override these messages or how to allow your application to have visibility of framework errors.

If an error occurs during or after parsing and binding is complete, it will be recorded in the WsReponse.Errors field. These types of errors are called service errors. For more information on service errors, refer to the GoDoc for CategorisedError below or http://granitic.io/1.0/ref/errors-and-messages.

Response writing

The serialisation of the data in a WsResponse to an HTTP response is handled by a component implementing WsResponseWriter. A component of this type will be automatically created for you when you enable the JsonWs or XmlWs facility.

Parameter binding

Parameter binding refers to the process of automatically capturing request query parameters and injecting them into fields on the WsRequest Body. It also refers to a similar process for extracting information from a request's path using regular expressions. See http://granitic.io/1.0/ref/parameter-binding for more details.

IAM and versioning

Granitic does not provide implementations of Identity Access Management or request versioning, but instead provides highly generic types to allow your application's implementations of these concepts to be integrated with Grantic's web service request processing. See the GoDoc for WsIdentifier, WsAccessChecker and handler/WsVersionAssessor and the iam package for more details.

HTTP status code determination

Unless your application defines its own HttpStatusCodeDeterminer, the eventual HTTP status code set on the response to a web service request it determined by examining the state of a WsResponse using the following logic:

1. If the WsResponse.HttpStatus field is non-zero, use that.

2. If the WsResponse.Errors.HttpStatus field is non-zero, use that.

3. If the WsResponse.Errors structure:

a) Contains one or more 'Unexpected' errors, use HTTP 500.

b) Contains an 'HTTP' error, convert that error's code to a number and use that.

c) Contains one or more 'Security' errors, use HTTP 401.

d) Contains one or more 'Client' errors, use HTTP 400.

e) Contains one or more 'Logic' errors, use HTTP 409.

4. Return HTTP 200.

Index

Package Files

error.go frameworkerror.go iam.go marshal.go parambinding.go params.go request.go response.go status.go

Constants

const (
    // An unhandled error that will generally result in an HTTP 500 status code being set.
    Unexpected = iota

    // A problem that the calling client has caused or could have foreseen, generally resulting in an HTTP 400 status code.
    Client

    // A problem that the calling client could be expected to have foreseen (email addres in use, for example) resulting in an HTTP 409.
    Logic

    // An access or authentication error that might result in an HTTP 401 or 403.
    Security

    // An error that forces a specific HTTP status code.
    HTTP
)
const (
    // Error encountered while trying to parse an HTTP request body into a struct
    Unmarshall = iota

    // Error encountered while mapping HTTP query parameters to fields on a struct
    QueryBind

    // Error encountered while mapping elements of an HTTP request's path to fields on a struct
    PathBind
)
const (
    UnableToParseRequest = "UnableToParseRequest"
    QueryTargetNotArray  = "QueryTargetNotArray"
    QueryWrongType       = "QueryWrongType"
    PathWrongType        = "PathWrongType"
    QueryNoTargetField   = "QueryNoTargetField"
)
const (
    // A normal outcome resulting in an HTTP 200 response.
    Normal = iota

    // A outcome with anticipated and handled errors resulting in a 4xx response.
    Error

    // An unexpected or unusual outcome resulting in a 5xx response.
    Abnormal
)

func CategoryToCode Uses

func CategoryToCode(c ServiceErrorCategory) string

CategoryToCode maps a ServiceErrorCategory to the category's name's first letter. For example, Security maps to 'S'

func CategoryToName Uses

func CategoryToName(c ServiceErrorCategory) string

CategoryToCode maps a ServiceErrorCategory to the category's name's first letter. For example, Security maps to 'Security'

func MergeHeaders Uses

func MergeHeaders(res *WsResponse, ch map[string]string, dh map[string]string) map[string]string

Merges together the headers that have been defined on the WsResponse, the static default headers attache to this writer and (optionally) those constructed by the ws.WsCommonResponseHeaderBuilder attached to this writer. The order of precedence, from lowest to highest, is static headers, constructed headers, headers in the WsResponse.

func WriteHeaders Uses

func WriteHeaders(w http.ResponseWriter, headers map[string]string)

WriteHeaders writes the supplied map as HTTP headers.

type AbnormalStatusWriter Uses

type AbnormalStatusWriter interface {
    // Write converts whatever data is present in the supplied state object to the HTTP output stream associated
    // with the current web service request.
    WriteAbnormalStatus(ctx context.Context, state *WsProcessState) error
}

Implemented by components able to write a valid response even if the request resulted in an abnormal (5xx) outcome.

type CategorisedError Uses

type CategorisedError struct {
    // The broad type of error, which influences the eventual HTTP status code set on the response.
    Category ServiceErrorCategory

    // A unique code that a caller can rely on to identify a specific error or that can be used to lookup an error message.
    Code string

    // A message suitable for displaying to the caller.
    Message string

    //If this error relates to a specific field or parameter in a web service request, this field is set to the name of that field.
    Field string
}

A service error with a concept of the general 'type' of error it is.

func NewCategorisedError Uses

func NewCategorisedError(category ServiceErrorCategory, code string, message string) *CategorisedError

NewCategorisedError creates a new CategorisedError with every field expect 'Field' set.

type DirectHTTPAccess Uses

type DirectHTTPAccess struct {
    // The HTTP response output stream.
    ResponseWriter http.ResponseWriter

    // The incoming HTTP request.
    Request *http.Request
}

Wraps the underlying low-level HTTP request and response writing objects.

type ErrorFormatter Uses

type ErrorFormatter interface {
    // FormatErrors converts the supplied errors into a structure that a response writer will use to write the errors to
    // the current HTTP response.
    FormatErrors(errors *ServiceErrors) interface{}
}

Interface for components able to convert a set of service errors into a structure suitable for serialisation.

type FrameworkErrorEvent Uses

type FrameworkErrorEvent string

Uniquely identifies a 'handled' failure during the parsing and binding phases

type FrameworkErrorGenerator Uses

type FrameworkErrorGenerator struct {
    Messages        map[FrameworkErrorEvent][]string
    HttpMessages    map[string]string
    FrameworkLogger logging.Logger
}

A FrameworkErrorGenerator can create error messages for errors that occur outside of application code and messages that should be displayed when generic HTTP status codes (404, 500, 503 etc) are set.

func (*FrameworkErrorGenerator) Error Uses

func (feg *FrameworkErrorGenerator) Error(e FrameworkErrorEvent, c ServiceErrorCategory, a ...interface{}) *CategorisedError

Error creates a service error given a framework error.

func (*FrameworkErrorGenerator) HttpError Uses

func (feg *FrameworkErrorGenerator) HttpError(status int, a ...interface{}) *CategorisedError

HttpError generates a message to be displayed to a caller when a generic HTTP status (404 etc) is encountered. If an error message is not defined for the supplied status, the message "HTTP (code)" is returned, e.g. "HTTP 101"

func (*FrameworkErrorGenerator) MessageCode Uses

func (feg *FrameworkErrorGenerator) MessageCode(e FrameworkErrorEvent, a ...interface{}) (message string, code string)

MessageCode returns a message and code for a Framework error event (leaving the caller to create a CategorisedError)

type GraniticHttpStatusCodeDeterminer Uses

type GraniticHttpStatusCodeDeterminer struct {
}

The default HttpStatusCodeDeterminer used by Granitic's XXXWs facilities. See the top of this page for rules on how this code is determined.

func (*GraniticHttpStatusCodeDeterminer) DetermineCode Uses

func (dhscd *GraniticHttpStatusCodeDeterminer) DetermineCode(response *WsResponse) int

DetermineCode examines the response and returns an HTTP status code according to the rules defined at the top of this GoDoc page.

type HttpStatusCodeDeterminer Uses

type HttpStatusCodeDeterminer interface {
    // DetermineCode returns the HTTP status code that should be set on the response.
    DetermineCode(response *WsResponse) int
}

Implemented by a component able to choose the most appropriate HTTP status code to set given the state of a WsResponse

type MarshalingWriter Uses

type MarshalingWriter interface {

    // MarshalAndWrite converts the data to some serialisable form (JSON, XML etc) and writes it to the HTTP output stream.
    MarshalAndWrite(data interface{}, w http.ResponseWriter) error
}

Implemented by components that can convert the supplied data into a form suitable for serialisation and write that serialised form to the HTTP output stream.

type MarshallingResponseWriter Uses

type MarshallingResponseWriter struct {
    // Injected automatically
    FrameworkLogger logging.Logger

    // Component able to calculate the HTTP status code that should be written to the HTTP response.
    StatusDeterminer HttpStatusCodeDeterminer

    // Component able to generate errors if a problem is encountered during marshalling.
    FrameworkErrors *FrameworkErrorGenerator

    // The common and static set of headers that should be written to all responses.
    DefaultHeaders map[string]string

    // Component able to wrap response data in a standardised structure.
    ResponseWrapper ResponseWrapper

    // Component able to dynamically generate additional headers to be written to the response.
    HeaderBuilder WsCommonResponseHeaderBuilder

    // Component able to format services errors in an application specific manner.
    ErrorFormatter ErrorFormatter

    // Component able to serialize the data to the HTTP output stream.
    MarshalingWriter MarshalingWriter
}

A response writer that uses automatic marshalling of structs to serialisable forms rather than using templates.

func (*MarshallingResponseWriter) Write Uses

func (rw *MarshallingResponseWriter) Write(ctx context.Context, state *WsProcessState, outcome WsOutcome) error

See WsResponseWriter.Write

func (*MarshallingResponseWriter) WriteAbnormalStatus Uses

func (rw *MarshallingResponseWriter) WriteAbnormalStatus(ctx context.Context, state *WsProcessState) error

See AbnormalStatusWriter.WriteAbnormalStatus

type ParamBinder Uses

type ParamBinder struct {
    // Injected by Granitic
    FrameworkLogger logging.Logger

    // Source of service errors for errors encountered while binding.
    FrameworkErrors *FrameworkErrorGenerator
}

Takes string parameters extracted from an HTTP request, converts them to Go native or Granitic nilable types and injects them into the RequestBody on a WsRequest.

func (*ParamBinder) AutoBindQueryParameters Uses

func (pb *ParamBinder) AutoBindQueryParameters(wsReq *WsRequest)

BindPathParameters takes the query parameters from an HTTP request and injects them into fields on the WsRequest.RequestBody assuming the parameters have exactly the same name as the target fields. Any errors encountered are recorded as framework errors in the WsRequest.

func (*ParamBinder) BindPathParameters Uses

func (pb *ParamBinder) BindPathParameters(wsReq *WsRequest, p *WsParams)

BindPathParameters takes strings extracted from an HTTP's request path (using regular expression groups) and injects them into fields on the WsRequest.RequestBody. Any errors encountered are recorded as framework errors in the WsRequest.

func (*ParamBinder) BindQueryParameters Uses

func (pb *ParamBinder) BindQueryParameters(wsReq *WsRequest, targets map[string]string)

BindPathParameters takes the query parameters from an HTTP request and injects them into fields on the WsRequest.RequestBody using the keys of the supplied map as the name of the target fields. Any errors encountered are recorded as framework errors in the WsRequest.

type ResponseWrapper Uses

type ResponseWrapper interface {
    // WrapResponse takes the supplied body and errors and wraps them in a standardised data structure.
    WrapResponse(body interface{}, errors interface{}) interface{}
}

Implemented by components able to take the body from an WsResponse and wrap it inside a container that will allow all responses to share a common structure.

type ServiceErrorCategory Uses

type ServiceErrorCategory int

The broad 'type' of a service error, used to determine the correct HTTP status code to use.

func CodeToCategory Uses

func CodeToCategory(c string) (ServiceErrorCategory, error)

CodeToCategory takes the short form of a category's name (its first letter, capitialised) an maps that to a ServiceErrorCategory

type ServiceErrorConsumer Uses

type ServiceErrorConsumer interface {
    // ProvideErrorFinder receives a ServiceErrorFinder
    ProvideErrorFinder(finder ServiceErrorFinder)
}

Implemented by components that require a ServiceErrorFinder to be injected into them

type ServiceErrorFinder Uses

type ServiceErrorFinder interface {
    //Find takes a code and returns the message and category for that error. Behaviour undefined if code is not
    // recognised.
    Find(code string) *CategorisedError
}

Implemented by a component that is able to find a message and error category given the code for an error

type ServiceErrors Uses

type ServiceErrors struct {
    // All services found, in the order in which they occured.
    Errors []CategorisedError

    // An externally computed HTTP status code that reflects the mix of errors in this structure.
    HttpStatus int

    // A component able to find additional information about error from that error's unique code.
    ErrorFinder ServiceErrorFinder
}

A structure that records each of the errors found during the processing of a request.

func (*ServiceErrors) AddError Uses

func (se *ServiceErrors) AddError(e *CategorisedError)

AddError records the supplied error.

func (*ServiceErrors) AddNewError Uses

func (se *ServiceErrors) AddNewError(category ServiceErrorCategory, label string, message string)

AddNewError creates a new CategorisedError from the supplied information and captures it.

func (*ServiceErrors) AddPredefinedError Uses

func (se *ServiceErrors) AddPredefinedError(code string, field ...string) error

AddPredefinedError creates a CategorisedError by looking up the supplied code and records that error. If the variadic field parameter is supplied, the created error will be associated with that field name.

func (*ServiceErrors) HasErrors Uses

func (se *ServiceErrors) HasErrors() bool

HasErrors returns true if one or more errors have been encountered and recorded.

type WsAccessChecker Uses

type WsAccessChecker interface {
    // Allowed returns true if the caller is allowed to have this request processed, false otherwise.
    Allowed(ctx context.Context, r *WsRequest) bool
}

WsIdentifier is implemented by components that are able to determine if a caller is allowed to have a request processed.

type WsCommonResponseHeaderBuilder Uses

type WsCommonResponseHeaderBuilder interface {
    BuildHeaders(ctx context.Context, state *WsProcessState) map[string]string
}

An object that constructs response headers that are common to all web service requests. These may typically be caching instructions or 'processing server' records. Implementations must be extremely cautious when using the information in the supplied WsProcess state as some values may be nil.

type WsFrameworkError Uses

type WsFrameworkError struct {
    // The phase of the request processing during which an error was encountered.
    Phase WsFrameworkPhase

    // The name of the field or parameter in the HTTP request with a problem
    ClientField string

    // The name of the field on the response body struct that was being written to
    TargetField string

    // A system generated message relating to the error.
    Message string

    // The value of the field/parameter that caused the error.
    Value string

    // For array parameters, the position in the array that caused the error.
    Position int

    // A system generated code for the error.
    Code string
}

An error encountered in early phases of request processing, before application code is invoked.

func NewPathBindFrameworkError Uses

func NewPathBindFrameworkError(message, code, target string) *WsFrameworkError

NewPathBindFrameworkError creates a WsFrameworkError with fields set appropriate for an error encountered during mapping elements of the HTTP request's path to fields on a WsRequest's Body.

func NewQueryBindFrameworkError Uses

func NewQueryBindFrameworkError(message, code, param, target string) *WsFrameworkError

NewQueryBindFrameworkError creates a WsFrameworkError with fields set appropriate for an error encountered during mapping of HTTP query parameters to fields on a WsRequest's Body

func NewUnmarshallWsFrameworkError Uses

func NewUnmarshallWsFrameworkError(message, code string) *WsFrameworkError

NewUnmarshallWsFrameworkError creates a WsFrameworkError with fields set appropriate for an error encountered during parsing of the HTTP request body.

type WsFrameworkPhase Uses

type WsFrameworkPhase int

The phase of the request processing during which an error was encountered.

type WsIdentifier Uses

type WsIdentifier interface {
    // Identify returns information about the caller derived request and a Context that might be different from the supplied Context.
    Identify(ctx context.Context, req *http.Request) (iam.ClientIdentity, context.Context)
}

WsIdentifier is implemented by components that are able to identify a caller based on a raw HTTP request (normally from headers and cookies). Implementations of this interface may return a new Context that supersedes the supplied Context.

type WsOutcome Uses

type WsOutcome uint

An enumeration of the high-level result of processing a request. Used internally.

type WsParams Uses

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

An abstraction of the HTTP query parameters or path parameters with type-safe accessors.

func NewWsParamsForPath Uses

func NewWsParamsForPath(targets []string, values []string) *WsParams

NewWsParamsForPath creates a WsParams used to store the elements of a request path extracted using regular expression groups.

func NewWsParamsForQuery Uses

func NewWsParamsForQuery(values url.Values) *WsParams

NewWsParamsForQuery creates a WsParams storing the HTTP query parameters from a request.

func (*WsParams) BoolValue Uses

func (wp *WsParams) BoolValue(key string) (bool, error)

BoolValue returns the bool representation of the specified parameter (using Go's bool conversion rules) or an error if no value exists for that parameter.

func (*WsParams) Exists Uses

func (wp *WsParams) Exists(key string) bool

Exists returns true if a parameter with the supplied name exists, even if that parameter's value is an empty string.

func (*WsParams) FloatNValue Uses

func (wp *WsParams) FloatNValue(key string, bits int) (float64, error)

FloatNValue returns a float representation of the specified parameter with the specified bit size, or an error if no value exists for that parameter or if the value could not be converted to a float.

func (*WsParams) IntNValue Uses

func (wp *WsParams) IntNValue(key string, bits int) (int64, error)

IntNValue returns a signed int representation of the specified parameter with the specified bit size, or an error if no value exists for that parameter or if the value could not be converted to an int.

func (*WsParams) MultipleValues Uses

func (wp *WsParams) MultipleValues(key string) bool

MultipleValues returns true if the parameter with the supplied name was set more than once (allowed for HTTP query parameters).

func (*WsParams) NotEmpty Uses

func (wp *WsParams) NotEmpty(key string) bool

NotEmpty returns true if a parameter with the supplied name exists and has a non-empty string representation.

func (*WsParams) ParamNames Uses

func (wp *WsParams) ParamNames() []string

ParamNames returns the names of all of the parameters stored

func (*WsParams) StringValue Uses

func (wp *WsParams) StringValue(key string) (string, error)

StringValue returns the string representation of the specified parameter or an error if no value exists for that parameter.

func (*WsParams) UIntNValue Uses

func (wp *WsParams) UIntNValue(key string, bits int) (uint64, error)

UIntNValue returns an unsigned int representation of the specified parameter with the specified bit size, or an error if no value exists for that parameter or if the value could not be converted to an unsigned int.

type WsProcessState Uses

type WsProcessState struct {
    // The representation of the incoming request at the time processing completed or failed.
    WsRequest *WsRequest

    // The representation of the data to be sent to the caller at the time processing completed or failed.
    WsResponse *WsResponse

    // The HTTP output stream.
    HttpResponseWriter *httpendpoint.HttpResponseWriter

    // Errors detected while processing the web service request. If set, supersedes the errors present in WsResponse field.
    ServiceErrors *ServiceErrors

    // Information about the caller or user of the web service.
    Identity iam.ClientIdentity

    // The HTTP status code to be set on the HTTP response.
    Status int
}

WsProcessState is wrapper for current state of request processing. This type is used by components implementing WsResponseWriter. Because a request may fail at many points during processing, there is no guarantee that any of the fields in this type are set, valid or complete, so this type must be used with caution.

func NewAbnormalState Uses

func NewAbnormalState(status int, w *httpendpoint.HttpResponseWriter) *WsProcessState

NewAbnormalState creates a new WsProcessState for a request that has resulted in an abnormal (HTTP 5xx) outcome).

type WsRequest Uses

type WsRequest struct {
    // The HTTP method (GET, POST etc) of the underlying HTTP request.
    HttpMethod string

    // If the HTTP request had a body and if the handler that generated this WsRequest implements WsUnmarshallTarget,
    // then RequestBody will contain a struct representation of the request body.
    RequestBody interface{}

    // A copy of the HTTP query parameters from the underlying HTTP request with type-safe accessors.
    QueryParams *WsParams

    // Information extracted from the path portion of the HTTP request using regular expression groups with type-safe accessors.
    PathParams []string

    // Problems encountered during the parsing and binding phases of request processing.
    FrameworkErrors []*WsFrameworkError

    // Information about the web service caller (if the handler has a WsIdentifier).
    UserIdentity iam.ClientIdentity

    //The underlying HTTP request and response  (if the handler was configured to pass
    // this information on).
    UnderlyingHTTP *DirectHTTPAccess

    //The component name of the handler that generated this WsRequest.
    ServingHandler string
    // contains filtered or unexported fields
}

Stores information about a web service request that has been either copied in or derived from an underlying HTTP request.

func (*WsRequest) AddFrameworkError Uses

func (wsr *WsRequest) AddFrameworkError(f *WsFrameworkError)

AddFrameworkError records a framework error.

func (*WsRequest) BoundFields Uses

func (wsr *WsRequest) BoundFields() types.StringSet

BoundFields returns the name of all of the names on the RequestBody that were explicitly set by the query/path parameter binding process.

func (*WsRequest) HasFrameworkErrors Uses

func (wsr *WsRequest) HasFrameworkErrors() bool

HasFrameworkErrors returns true if one or more framework errors have been recorded.

func (*WsRequest) RecordFieldAsBound Uses

func (wsr *WsRequest) RecordFieldAsBound(fieldName string)

RecordFieldAsBound is used to record the fact that a field on the RequestBody was explicitly set by the query/path parameter binding process.

func (*WsRequest) WasFieldBound Uses

func (wsr *WsRequest) WasFieldBound(fieldName string) bool

WasFieldBound returns true if a field on the RequestBody was explicitly set by the query/path parameter binding process.

type WsResponse Uses

type WsResponse struct {
    // An instruction that the HTTP status code should be set to this value (if the value is greater than 99). Generally
    // not set - the response writer will determine the correct status to use.
    HttpStatus int

    // If the web service call resulted in data that should be written as the body of the HTTP response is stored in this field.
    // Application code must set this field explicitly.
    Body interface{}

    // All of the errors encountered while processing this request.
    Errors *ServiceErrors

    // Headers that should be set on the HTTP response.
    Headers map[string]string

    // If the type of response rendering is template based (e.g. using the XmlWs facility in template mode), this field
    // can be used to override any default templates or the template associated with the handler that created this response.
    Template string
}

Contains data that is relevant to the rendering of the result of a web service request to an HTTP response. This type is agnostic of the format (JSON, XML etc) that is to be used to render the response.

func NewWsResponse Uses

func NewWsResponse(errorFinder ServiceErrorFinder) *WsResponse

NewWsResponse creates a valid but empty WsReponse with Errors structure initialised.

type WsResponseWriter Uses

type WsResponseWriter interface {
    // Write converts whatever data is present in the supplied state object to the HTTP output stream associated
    // with the current web service request.
    Write(ctx context.Context, state *WsProcessState, outcome WsOutcome) error
}

Implemented by components able write the result of a web service call to an HTTP response.

type WsUnmarshaller Uses

type WsUnmarshaller interface {
    // Unmarshall deserialises an HTTP request body and converts it to a struct.
    Unmarshall(ctx context.Context, req *http.Request, wsReq *WsRequest) error
}

Implement by components that are able to convert an HTTP request body into a struct.

Directories

PathSynopsis
handlerPackage handler provides the types used to coordinate the processing of a web service request.
jsonPackage json defines types that are specific to handling web service requests and responses as JSON.
xmlPackage xml defines types that are specific to handling web service requests and responses as XML.

Package ws imports 12 packages (graph) and is imported by 10 packages. Updated 2018-10-24. Refresh now. Tools for package owners.