package module
Version: v0.0.0-...-a78facf Latest Latest

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

Go to latest
Published: May 16, 2017 License: MIT Imports: 4 Imported by: 1



A GopherJS binding and generator for gRPC-web


Generate GopherJS bindings for gRPC-web


A JS file containing all gRPC-web definitions




View Source
const (
	// Ok is Not an error; returned on success.
	Ok = StatusCode(iota)

	// Cancelled is returned when the operation was cancelled (typically by the caller).

	// Unknown error. An example of where this error may be returned is if 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.

	// InvalidArgument is returned when the Client specified an invalid argument.
	// Note that this differs from FailedPrecondition.
	// InvalidArgument indicates arguments that are problematic regardless
	// of the state of the system (e.g., a malformed file name).

	// DeadlineExceeded is returned when the deadlined expired before 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 enough for the deadline to expire.

	// NotFound is returned when some requested entity (e.g., file or directory) was not found.

	// AlreadyExists is returned when some entity that we attempted to create
	// (e.g., file or directory) already exists.

	// PermissionDenied is returned when the caller does not have permission
	// to execute the specified operation. PermissionDenied must not be used
	// for rejections caused by exhausting some resource
	// (use ResourceExhausted instead for those errors).
	// PermissionDenied must not be used if the caller can not be identified
	// (use Unautheticated instead for those errors).

	// Unauthenticated is returned when the request does not have valid
	// authentication credentials for the operation.

	// ResourceExhausted is returned when some resource has been exhausted,
	// perhaps a per-user quota, or perhaps the entire file system is out of space.

	// FailedPrecondition is returned when an operation was rejected because
	// the system is not in a state required for the operation's execution.
	// For example, directory to be deleted may be non-empty,
	// an rmdir operation is applied to a non-directory, etc.
	// A litmus test that may help a service implementor in deciding
	// between FailedPrecondition, 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., restarting a read-modify-write sequence).
	//  (c) Use FailedPrecondition 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, FailedPrecondition
	//      should be returned since the client should not retry unless
	//      they have first fixed up the directory by deleting files from it.
	//  (d) Use FailedPrecondition if the client performs conditional
	//      REST Get/Update/Delete on a resource and the resource on the
	//      server does not match the condition. E.g., conflicting
	//      read-modify-write on the same resource.

	// Aborted is returned when the operation was aborted, typically due to a
	// concurrency issue like sequencer check failures, transaction aborts, etc.
	// See litmus test above for deciding between FailedPrecondition, Aborted,
	// and Unavailable.

	// OutOfRange is returned when an 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 OutOfRange if asked to read from
	// an offset past the current file size.
	// There is a fair bit of overlap between FailedPrecondition and
	// OutOfRange. We recommend using OutOfRange (the more specific error)
	// when it applies so that callers who are iterating through a space can
	// easily look for an OutOfRange error to detect when they are done.

	// Unimplemented is returned when an operation is not implemented or not
	// supported/enabled in this service.

	// Internal indicates an internal error. Means some invariants expected by underlying System has
	// been broken. If you see one of these errors, Something is very broken.

	// Unavailable indicates the service is currently unavailable. This is a most likely a transient
	// condition and may be corrected by retrying with a backoff.
	// See litmus test above for deciding between FailedPrecondition, Aborted,
	// and Unavailable.

	// DataLoss indicates unrecoverable data loss or corruption.
View Source
const (
	GET = HTTPMethod(iota)

Define HTTP methods

View Source
const (
	READABLE = EventType("readable")
	DATA     = EventType("data")
	END      = EventType("end")
	CLOSE    = EventType("close")
	ERROR    = EventType("error")

All the defined EventTypes


View Source
var EOF = &Error{Code: Ok, Message: "EOF"}

EOF is sent when a streaming request is finished


This section is empty.


type CallOption

type CallOption func(*XHRNodeReadableStream)

CallOption can be used to configure a call

func WithMetadata

func WithMetadata(m Metadata) CallOption

WithMetadata adds the metadata as headers to the request

type Error

type Error struct {
	Code    StatusCode `js:"code"`
	Message string     `js:"message"`

Error is a gRPC-web Error

func (*Error) Error

func (e *Error) Error() string

type EventType

type EventType string

EventType is a NodeReadableStream event type Defined in

type GatewayClientBase

type GatewayClientBase struct {

GatewayClientBase represents the gRPC-web GatewayClientBase class.

func NewGatewayClientBase

func NewGatewayClientBase() *GatewayClientBase

NewGatewayClientBase constructs a new GatewayClientBase from the JS class constructor.

func (*GatewayClientBase) ParseRPCStatus

func (g *GatewayClientBase) ParseRPCStatus(rawBytes []byte) (s *Status, err error)

ParseRPCStatus parses raw bytes to a Status.

func (*GatewayClientBase) RPCCall

func (g *GatewayClientBase) RPCCall(endpoint string, request ProtoMessage, opts ...CallOption) (resp []byte, err error)

RPCCall makes an XHR request to the provided endpoint using the provided request. It returns a byte representation of the response, or an error

func (*GatewayClientBase) ServerStreaming

func (g *GatewayClientBase) ServerStreaming(endpoint string, request ProtoMessage, opts ...CallOption) (*StreamReader, error)

ServerStreaming makes an XHR request to the provided streaming endpoint using the provided request. It returns client for reading messages.

type HTTPMethod

type HTTPMethod int

HTTPMethod is an enum for valid HTTP methods

func (HTTPMethod) String

func (h HTTPMethod) String() string

type Metadata

type Metadata map[string]string

Metadata is a simple string to string map.

type ProtoMessage

type ProtoMessage interface {
	Serialize() ([]byte, error)
	Deserialize([]byte) error

ProtoMessage must be implemented by all generated proto structs

type ResponseCallback

type ResponseCallback func(status *Status, resp []byte)

ResponseCallback is called on the response from a method

type Status

type Status struct {
	Code     StatusCode `js:"code"`
	Details  string     `js:"details"`
	Metadata Metadata   `js:"metadata"`

Status is a gRPC-web Status.

type StatusCode

type StatusCode int

StatusCode is a gRPC-web StatusCode.

func FromHTTPStatus

func FromHTTPStatus(HTTPCode int) StatusCode

FromHTTPStatus converts a HTTP Status code to a StatusCode

type StreamReader

type StreamReader struct {
	// contains filtered or unexported fields

func NewStreamReader

func NewStreamReader(respChan <-chan []byte, errChan <-chan error) *StreamReader

func (*StreamReader) Recv

func (s *StreamReader) Recv() ([]byte, error)

type XHRIO

type XHRIO struct {

XHRIO encapsulates the google XhrIO class.

func NewXHRIO

func NewXHRIO() *XHRIO

NewXHRIO initializes an XHRIO object.

func (*XHRIO) Abort

func (x *XHRIO) Abort()

Abort closes the XHR stream

func (*XHRIO) Send

func (x *XHRIO) Send(endpoint string, method HTTPMethod, data []byte)

Send sends the data to the endpoint using the method

func (*XHRIO) SetRequestHeader

func (x *XHRIO) SetRequestHeader(key, value string)

SetRequestHeader sets the header key to value

func (*XHRIO) SetTimeout

func (x *XHRIO) SetTimeout(timeout time.Duration)

SetTimeout sets the header key to value

type XHRNodeReadableStream

type XHRNodeReadableStream struct {
	// contains filtered or unexported fields

XHRNodeReadableStream encapsulates a google XhrNodeReadableStream class

func NewXHRNodeReadableStream

func NewXHRNodeReadableStream(xhrIO *XHRIO) *XHRNodeReadableStream

NewXHRNodeReadableStream initializes an XHRNodeReadableStream object with the provided XhrIO.

func (*XHRNodeReadableStream) Abort

func (x *XHRNodeReadableStream) Abort()

Abort closes the stream

func (*XHRNodeReadableStream) On

func (x *XHRNodeReadableStream) On(event EventType, callback func(*js.Object))

On sets the callback handler for the given event


Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
t or T : Toggle theme light dark auto
y or Y : Canonical URL