Version: v0.0.0-...-892988b Latest Latest

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

Go to latest
Published: Jul 30, 2019 License: MIT Imports: 7 Imported by: 1




This section is empty.


View Source
var ErrUnknown = errors.New("unknown message type")

ErrUnknown the message type provided does not match any known types


func ParseClient

func ParseClient(src []byte) (Type, IMessage, error)

ParseClient attempts to coerce an incoming json message into it's respective IMessage implementing Message struct. Will return an error if the type cannot be found (ErrUnknown), or an error if the message validation is not met

func ParseServer

func ParseServer(src []byte) (Type, IMessage, error)

ParseServer attempts to coerce an incoming json message into it's respective IMessage implementing Message struct. Will return an error if the type cannot be found (ErrUnknown), or an error if the message validation is not met

func TypeToString

func TypeToString(mt Type) string

TypeToString converts an incoming message type to it's string enum equivalent


type Ack

type Ack struct {

	ID string `json:"id"`

Ack is a server echo response that a command message was received

type Add

type Add struct {

	ID    string `json:"id"`
	Phase string `json:"phase"`
	Body  string `json:"body"` //hex encoded

Add tells the server to add a message to the mailbox for retrieval later. The body portion is hex encoded.

type Allocate

type Allocate struct {

Allocate is the client asking for a nameplate to be reserved for them to use. The server should respond with an Allocated response

type Allocated

type Allocated struct {

	Nameplate string `json:"nameplate"`

Allocated server response to the Allocate. Responds with the allocated nameplate

type Bind

type Bind struct {

	AppID string `json:"appid"`
	Side  string `json:"side"`

Bind allows the client to declare itself to the server and should be the first message the client sends. No other client messages will be accepted until this one is received.

type Claim

type Claim struct {

	Nameplate string `json:"nameplate"`

Claim allows the client to reserve an arbitrary nameplate of their choosing (given it is available)

type Claimed

type Claimed struct {

	Mailbox string `json:"mailbox"`

Claimed is the server response to the Claim responding with the claimed mailbox

type Close

type Close struct {

	Mood    string `json:"mood"`    //not sure what these values are actually
	Mailbox string `json:"mailbox"` //optional

Close tells the server that the client is closing, or terminating it's binding to the mailbox. It does not release the mailbox.

type Closed

type Closed struct {

Closed confirms to the client that the server has closed their mailbox binding

type Echo

type Echo []byte

Echo wraps a []byte slice to fool the JSON encoder into not string encoding this value. This is used in message loopback, or echo-ing the original client message while maintaining the JSON format.

func (Echo) MarshalJSON

func (e Echo) MarshalJSON() ([]byte, error)

MarshalJSON turns this into JSON. For this instance, it is a strait copy so no data wrangling happens.

type Error

type Error struct {

	Error string `json:"error"`
	Orig  Echo   `json:"orig"` //original message

Error is a server response to errors in client messages.

type IMessage

type IMessage interface {
	GetType() Type
	GetID() string

IMessage interface is used for tagging message types. Basically just wraps them up with a dummy function so reflection can grab them a bit easier

type List

type List struct {

List is a request from the client to have the server reply with the available nameplates. The server may deny this request. The server fulfills this with the Nameplates

type MailboxMessage

type MailboxMessage struct {

	Side  string `json:"side"`
	Phase string `json:"phase"`
	Body  string `json:"body"` //hex encoded
	MsgID string `json:"msg_id"`

MailboxMessage is the server pushing a mailbox message entry to the client The body field is hex encoded.

type Message

type Message struct {
	Type Type `json:"type"`

	ID         *string  `json:"id,omitempty"`
	ServerTime UnixTime `json:"server_tx,omitempty"`

Message base object for communication messages

func NewMessage

func NewMessage(mt Type) *Message

NewMessage returns a new Message object with the type filled in

func NewServerMessage

func NewServerMessage(mt Type) *Message

NewServerMessage returns a new Message object with the type and server time filled in

func (Message) GetID

func (m Message) GetID() string

GetID implements the IMessage interface, returning the client's message ID for acknowledgement

func (Message) GetType

func (m Message) GetType() Type

GetType implements the IMessage interface

type NameplateEntry

type NameplateEntry struct {
	ID string `json:"id"`

NameplateEntry is an individual entry in the nameplate response, identified by it's ID

type Nameplates

type Nameplates struct {

	Nameplates []NameplateEntry `json:"nameplates"`

Nameplates is the server response to a clients list request (List), and responds with the available nameplates

type Open

type Open struct {

	Mailbox string `json:"mailbox"`

Open binds the client to a mailbox. Can only be called once per connection. After this point, old messages are transmited as well as listening for updates to the mailbox in which it will push new ones to the client

type Ping

type Ping struct {
	Ping int `json:"ping"`

Ping is a protocol specific ping/pong test from client to server. Ping is sent from client

type Pong

type Pong struct {
	Pong int `json:"pong"`

Pong is a protocol specific ping/pong test from client to server. Pong is sent from server in response

type Release

type Release struct {

	Nameplate string `json:"nameplate"` //optional

Release tells the server that the client is done with their nameplate/mailbox. The Nameplate field is optional, but should match the same one from Claim, or what is allocated to the client.

type Released

type Released struct {

Released is the servers confirmation that it has released the clients nameplate/mailbox as instructed from the Release

type Type

type Type int

Type enumerates the available message types accepted

const (
	TypeUnknown Type = iota


	TypeError //Important! keep this one last

Available message type enumerations

func DetectType

func DetectType(src []byte) (Type, error)

DetectType takes an incoming JSON string as bytes and attempts to find the messages type field by unmarshalling it into a dummy object. Surprisingly, this was faster then RegExp.

func TypeFromString

func TypeFromString(str string) Type

TypeFromString converts an incoming string to it's Type equivalent, or TypeUnknown if no matches

func (*Type) FromString

func (mt *Type) FromString(str string)

FromString converts the incoming string into the message type it matches, or TypeUnknown if no matches

func (Type) MarshalText

func (mt Type) MarshalText() ([]byte, error)

MarshalText converts the enum into a string/text representation

func (Type) String

func (mt Type) String() string

func (*Type) UnmarshalText

func (mt *Type) UnmarshalText(src []byte) error

UnmarshalText converts the string representation, back into the enum

type UnixTime

type UnixTime struct {
	Time *time.Time

UnixTime wraps a time.Time pointer so that we can control the json encoding/decoding of the value. The wormhole protocol has it's time values in unix seconds since epoch.

func NewUnixTime

func NewUnixTime() UnixTime

NewUnixTime returns a new UnixTime object filled to time.Now()

func (UnixTime) MarshalJSON

func (t UnixTime) MarshalJSON() ([]byte, error)

MarshalJSON reads the json

func (*UnixTime) UnmarshalJSON

func (t *UnixTime) UnmarshalJSON(src []byte) error

UnmarshalJSON writes the json

type Welcome

type Welcome struct {

	Info WelcomeInfo `json:"welcome"`

Welcome used for the server to introduce itself to clients when they connect

type WelcomeInfo

type WelcomeInfo struct {
	//MOTD Message Of The Day. Will be displayed
	//to connecting clients when received
	MOTD *string `json:"motd,omitempty"`

	//Error displays an error message to clients
	//on connection and they will close immediately.
	//Used to anounce service termination
	Error *string `json:"error,omitempty"`

	//Version advertises a new CLI client version to
	//the clients
	Version *string `json:"current_cli_version,omitempty"`

WelcomeInfo wraps up the welcome information for servers to respond to clients with. This is JSON encoded so the type is provided for convenience.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL