koinosmq

type BroadcastHandlerFunc ¶

type BroadcastHandlerFunc = func(topic string, data []byte)

BroadcastHandlerFunc Function type to handle a broadcast message

type CheckRetryResult ¶

type CheckRetryResult struct {
	DoRetry bool
	Timeout time.Duration
}

CheckRetryResult represents describes whether a retry is requested, and how long to timeout first

type Client ¶

type Client struct {
	/**
	 * Remote address to connect to.
	 */
	Address string
	// contains filtered or unexported fields
}

Client AMPQ Golang Wrapper

- Each RPC message has an rpcService - Queue for RPC of type T is kept in queue named `koins_rpc_T` - RPC messages per node type - Single global exchange for events, all node types

func NewClient(addr string, rpcRetryPolicy RetryPolicy) *Client

func (c *Client) Broadcast(ctx context.Context, contentType ContentType, topic string, args []byte) error

func (c *Client) RPC(ctx context.Context, contentType ContentType, rpcService string, args []byte) ([]byte, error)

func (c *Client) SetNumConsumers(rpcReturnNumConsumers int)

func (c *Client) Start(ctx context.Context) <-chan struct{}

type ContentType ¶

type ContentType string

type ExponentialBackoffOptions ¶

type ExponentialBackoffOptions struct {
	MaxTimeout  time.Duration
	Exponent    float32
	NextTimeout time.Duration
}

ExponentialBackoffOptions are the options for the exponential backoff policy

type RPCCallResult ¶

type RPCCallResult struct {
	Result []byte
	Error  error
}

RPCCallResult is the result of an rpc call

type RPCHandlerFunc ¶

type RPCHandlerFunc = func(rpcType string, data []byte) ([]byte, error)

RPCHandlerFunc Function type to handle an RPC message

type RequestHandler ¶

type RequestHandler struct {
	/**
	 * Remote address to connect to.
	 */
	Address string
	// contains filtered or unexported fields
}

RequestHandler AMPQ Golang Wrapper

- Each RPC message has an rpcType - Queue for RPC of type T is kept in queue named `koins_rpc_T` - RPC messages per node type - Single global exchange for events, all node types

func NewRequestHandler(addr string, consumers uint, replyRetryPolicy RetryPolicy) *RequestHandler

func (r *RequestHandler) SetBroadcastHandler(topic string, handler BroadcastHandlerFunc)

func (r *RequestHandler) SetRPCHandler(rpcType string, handler RPCHandlerFunc)

func (r *RequestHandler) Start(ctx context.Context) <-chan struct{}

type RetryPolicy ¶

type RetryPolicy int

RetryPolicy is an enum

const (
	// NoRetry does not retry
	NoRetry RetryPolicy = iota
	// ExponentialBackoff retires forever, with exponentially increading sleep
	ExponentialBackoff
)