event

Documentation

Index

• Constants
• type Bus
  • func New() Bus
• type BusController
• type BusPublisher
• type BusSubscriber
• type Client
  • func NewClient(address, path string, eventBus Bus) *Client
  • func (client *Client) EventBus() Bus
  • func (client *Client) Start() error
  • func (client *Client) Stop()
  • func (client *Client) Subscribe(topic string, fn interface{}, serverAddr, serverPath string)
  • func (client *Client) SubscribeOnce(topic string, fn interface{}, serverAddr, serverPath string)
• type ClientArg
• type ClientService
  • func (service *ClientService) PushEvent(arg *ClientArg, reply *bool) error
• type EventBus
  • func (bus *EventBus) HasCallback(topic string) bool
  • func (bus *EventBus) Publish(topic string, args ...interface{})
  • func (bus *EventBus) Subscribe(topic string, fn interface{}) error
  • func (bus *EventBus) SubscribeAsync(topic string, fn interface{}, transactional bool) error
  • func (bus *EventBus) SubscribeOnce(topic string, fn interface{}) error
  • func (bus *EventBus) SubscribeOnceAsync(topic string, fn interface{}) error
  • func (bus *EventBus) Unsubscribe(topic string, handler interface{}) error
  • func (bus *EventBus) WaitAsync()
• type NetworkBus
  • func NewNetworkBus(address, path string) *NetworkBus
  • func (networkBus *NetworkBus) EventBus() Bus
  • func (networkBus *NetworkBus) Start() error
  • func (networkBus *NetworkBus) Stop()
• type NetworkBusService
• type Server
  • func NewServer(address, path string, eventBus Bus) *Server
  • func (server *Server) EventBus() Bus
  • func (server *Server) HasClientSubscribed(arg *SubscribeArg) bool
  • func (server *Server) Start() error
  • func (server *Server) Stop()
• type ServerService
  • func (service *ServerService) Register(arg *SubscribeArg, success *bool) error
• type SubscribeArg
• type SubscribeType

Constants

const (
	// PublishService - Client service method
	PublishService = "ClientService.PushEvent"
)

const (
	// RegisterService - Server subscribe service method
	RegisterService = "ServerService.Register"
)

Types

type Bus

type Bus interface {
	BusController
	BusSubscriber
	BusPublisher
}

Bus englobes global (subscribe, publish, control) bus behavior

func New

func New() Bus

New returns new EventBus with empty handlers.

type BusController

type BusController interface {
	HasCallback(topic string) bool
	WaitAsync()
}

BusController defines bus control behavior (checking handler's presence, synchronization)

type BusPublisher

type BusPublisher interface {
	Publish(topic string, args ...interface{})
}

BusPublisher defines publishing-related bus behavior

type BusSubscriber

type BusSubscriber interface {
	Subscribe(topic string, fn interface{}) error
	SubscribeAsync(topic string, fn interface{}, transactional bool) error
	SubscribeOnce(topic string, fn interface{}) error
	SubscribeOnceAsync(topic string, fn interface{}) error
	Unsubscribe(topic string, handler interface{}) error
}

BusSubscriber defines subscription-related bus behavior

type Client

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

Client - object capable of subscribing to a remote event bus

func NewClient

func NewClient(address, path string, eventBus Bus) *Client

NewClient - create a client object with the address and server path

func (*Client) EventBus

func (client *Client) EventBus() Bus

EventBus - returns the underlying event bus

func (*Client) Start

func (client *Client) Start() error

Start - starts the client service to listen to remote events

func (*Client) Stop

func (client *Client) Stop()

Stop - signal for the service to stop serving

func (*Client) Subscribe

func (client *Client) Subscribe(topic string, fn interface{}, serverAddr, serverPath string)

Subscribe subscribes to a topic in a remote event bus

func (*Client) SubscribeOnce

func (client *Client) SubscribeOnce(topic string, fn interface{}, serverAddr, serverPath string)

SubscribeOnce subscribes once to a topic in a remote event bus

type ClientArg

type ClientArg struct {
	Args  []interface{}
	Topic string
}

ClientArg - object containing event for client to publish locally

type ClientService

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

ClientService - service object listening to events published in a remote event bus

func (*ClientService) PushEvent

func (service *ClientService) PushEvent(arg *ClientArg, reply *bool) error

PushEvent - exported service to listening to remote events

type EventBus

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

EventBus - box for handlers and callbacks.

func (*EventBus) HasCallback

func (bus *EventBus) HasCallback(topic string) bool

HasCallback returns true if exists any callback subscribed to the topic.

func (*EventBus) Publish

func (bus *EventBus) Publish(topic string, args ...interface{})

Publish executes callback defined for a topic. Any additional argument will be transferred to the callback.

func (*EventBus) Subscribe

func (bus *EventBus) Subscribe(topic string, fn interface{}) error

Subscribe subscribes to a topic. Returns error if `fn` is not a function.

func (*EventBus) SubscribeAsync

func (bus *EventBus) SubscribeAsync(topic string, fn interface{}, transactional bool) error

SubscribeAsync subscribes to a topic with an asynchronous callback Transactional determines whether subsequent callbacks for a topic are run serially (true) or concurrently (false) Returns error if `fn` is not a function.

func (*EventBus) SubscribeOnce

func (bus *EventBus) SubscribeOnce(topic string, fn interface{}) error

SubscribeOnce subscribes to a topic once. Handler will be removed after executing. Returns error if `fn` is not a function.

func (*EventBus) SubscribeOnceAsync

func (bus *EventBus) SubscribeOnceAsync(topic string, fn interface{}) error

SubscribeOnceAsync subscribes to a topic once with an asynchronous callback Handler will be removed after executing. Returns error if `fn` is not a function.

func (*EventBus) Unsubscribe

func (bus *EventBus) Unsubscribe(topic string, handler interface{}) error

Unsubscribe removes callback defined for a topic. Returns error if there are no callbacks subscribed to the topic.

func (*EventBus) WaitAsync

func (bus *EventBus) WaitAsync()

WaitAsync waits for all async callbacks to complete

type NetworkBus

type NetworkBus struct {
	*Client
	*Server
	// contains filtered or unexported fields
}

NetworkBus - object capable of subscribing to remote event buses in addition to remote event busses subscribing to it's local event bus. Compoed of a server and client

func NewNetworkBus

func NewNetworkBus(address, path string) *NetworkBus

NewNetworkBus - returns a new network bus object at the server address and path

func (*NetworkBus) EventBus

func (networkBus *NetworkBus) EventBus() Bus

EventBus - returns wrapped event bus

func (*NetworkBus) Start

func (networkBus *NetworkBus) Start() error

Start - helper method to serve a network bus service

func (*NetworkBus) Stop

func (networkBus *NetworkBus) Stop()

Stop - signal for the service to stop serving

type NetworkBusService

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

NetworkBusService - object capable of serving the network bus

type Server

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

Server - object capable of being subscribed to by remote handlers

func NewServer

func NewServer(address, path string, eventBus Bus) *Server

NewServer - create a new Server at the address and path

func (*Server) EventBus

func (server *Server) EventBus() Bus

EventBus - returns wrapped event bus

func (*Server) HasClientSubscribed

func (server *Server) HasClientSubscribed(arg *SubscribeArg) bool

HasClientSubscribed - True if a client subscribed to this server with the same topic

func (*Server) Start

func (server *Server) Start() error

Start - starts a service for remote clients to subscribe to events

func (*Server) Stop

func (server *Server) Stop()

Stop - signal for the service to stop serving

type ServerService

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

ServerService - service object to listen to remote subscriptions

func (*ServerService) Register

func (service *ServerService) Register(arg *SubscribeArg, success *bool) error

Register - Registers a remote handler to this event bus for a remote subscribe - a given client address only needs to subscribe once event will be republished in local event bus

type SubscribeArg

type SubscribeArg struct {
	ClientAddr    string
	ClientPath    string
	ServiceMethod string
	SubscribeType SubscribeType
	Topic         string
}

SubscribeArg - object to hold subscribe arguments from remote event handlers

type SubscribeType

type SubscribeType int

SubscribeType - how the client intends to subscribe

const (
	// Subscribe - subscribe to all events
	Subscribe SubscribeType = iota
	// SubscribeOnce - subscribe to only one event
	SubscribeOnce
)