spirit

package module
v0.3.4 Latest Latest
Warning

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

 Go to latest Published: Mar 6, 2017 License: Apache-2.0 Imports: 32 Imported by: 10

README

spirit

base component framework

Documentation

Index

Constants

View Source 
const (
	SIG_PAUSE  = 1000
	SIG_RESUME = 1001
	SIG_STOP   = 1002
)
View Source 
const (
	STATUS_READY    ComponentStatus = 0
	STATUS_RUNNING                  = 1
	STATUS_PAUSED                   = 2
	STATUS_STOPPING                 = 3
	STATUS_STOPPED                  = 4
)
View Source 
const (
	ERROR_MSG_ADDR           = "-100"
	ERROR_MSG_ADDR_INT int32 = -100
)
View Source 
const (
	EVENT_CMD_STOP = "EVENT_CMD_STOP"

	EVENT_RECEIVER_STOPPED           = "EVENT_RECEIVER_STOPPED"
	EVENT_RECEIVER_STARTED           = "EVENT_RECEIVER_STARTED"
	EVENT_RECEIVER_MSG_COUNT_UPDATED = "EVENT_RECEIVER_MSG_COUNT_UPDATED"

	EVENT_RECEIVER_MSG_RECEIVED = "EVENT_RECEIVER_MSG_RECEIVED"
	EVENT_RECEIVER_MSG_ERROR    = "EVENT_RECEIVER_MSG_ERROR"
	EVENT_RECEIVER_MSG_DELETED  = "EVENT_RECEIVER_MSG_DELETED"

	EVENT_HEARTBEAT = "EVENT_HEARTBEAT"

	EVENT_BEFORE_MESSAGE_HOOK = "EVENT_BEFORE_MESSAGE_HOOK"
	EVENT_AFTER_MESSAGE_HOOK  = "EVENT_AFTER_MESSAGE_HOOK"

	EVENT_BEFORE_MESSAGE_SEND = "EVENT_BEFORE_MESSAGE_SEND"
	EVENT_AFTER_MESSAGE_SEND  = "EVENT_AFTER_MESSAGE_SEND"

	EVENT_BASE_COMPONENT_STOPPING = "EVENT_BASE_COMPONENT_STOPPING"
	EVENT_BASE_COMPONENT_STOPPED  = "EVENT_BASE_COMPONENT_STOPPED"

	EVENT_BASE_COMPONENT_INTERNAL_MESSAGE = "EVENT_BASE_COMPONENT_INTERNAL_MESSAGE"
)
View Source 
const (
	INSTANCE_RUNNING = "Running"
	INSTANCE_EXITED  = "Exited"
)
View Source 
const (
	BIG_DATA_MESSAGE_ID           = "BIG_DATA_MESSAGE_ID"
	MAX_DATA_LENGTH               = 1024 * 30 //30k
	BIG_DATA_REDIS_EXPIRE_SECONDS = 600
	REDIS_DATA_SIZE               = 1024 * 512 //512K
)
View Source 
const (
	SPIRIT_CHILD_INSTANCE = "SPIRIT_CHILD_INSTANCE"
	SPIRIT_BIN_HOME       = "SPIRIT_BIN_HOME"
)
View Source 
const (
	EXT_SPIRIT = ".spirit"

	ENV_NAME = "SPIRIT_ENV"
	ENV_EXT  = ".env"
)
View Source 
const (
	FILE_CHUNK = 8192
)
View Source 
const (
	SPIRIT = "spirit"
)
View Source 
const SPIRIT_ERR_NS = "SPIRIT"

Variables

View Source 
var (
	ERR_MESSAGE_GRAPH_ADDRESS_NOT_FOUND = errors.TN(SPIRIT_ERR_NS, 1, "could not found next address in graph, current component name: {{.compName}}, port name: {{.portName}}")
	ERR_MESSAGE_GRAPH_IS_NIL            = errors.TN(SPIRIT_ERR_NS, 2, "component graph is nil")
	ERR_MESSAGE_ADDRESS_IS_EMPTY        = errors.TN(SPIRIT_ERR_NS, 3, "component message address is empty")
	ERR_MESSAGE_SERIALIZE_FAILED        = errors.TN(SPIRIT_ERR_NS, 4, "component message serialize failed, err: {{.err}}")

	ERR_COMPONENT_HANDLER_RETURN_ERROR = errors.TN(SPIRIT_ERR_NS, 5, "component handler return error, component name: {{.name}}, port: {{.port}}, error: {{.err}}")
	ERR_COMPONENT_HANDLER_NOT_EXIST    = errors.TN(SPIRIT_ERR_NS, 6, "component handler not exist, component name: {{.name}},  handler name: {{.handlerName}}")

	ERR_SENDER_CREDENTIAL_IS_NIL = errors.TN(SPIRIT_ERR_NS, 8, "credential is nil, type: {{.type}}, url: {{.url}}")
	ERR_SENDER_MNS_CLIENT_IS_NIL = errors.TN(SPIRIT_ERR_NS, 9, "sender mns client is nil, type: {{.type}}, url: {{.url}}")
	ERR_SENDER_SEND_FAILED       = errors.TN(SPIRIT_ERR_NS, 10, "component message send failed, type: {{.type}}, url: {{.url}}, err:{{.err}}")

	ERR_SENDER_CREATE_FAILED    = errors.TN(SPIRIT_ERR_NS, 11, "create sender failed, driver type: {{.type}}")
	ERR_SENDER_DRIVER_NOT_EXIST = errors.TN(SPIRIT_ERR_NS, 12, "message sender driver not exist, type: {{.type}}")
	ERR_SENDER_BAD_DRIVER       = errors.TN(SPIRIT_ERR_NS, 13, "bad message sender driver of {{.type}}")

	ERR_RECEIVER_CREDENTIAL_IS_NIL     = errors.TN(SPIRIT_ERR_NS, 14, "credential is nil, type: {{.type}}")
	ERR_RECEIVER_MNS_CLIENT_IS_NIL     = errors.TN(SPIRIT_ERR_NS, 15, "receiver mns client is nil, type: {{.type}}, url: {{.url}}")
	ERR_RECEIVER_DELETE_MSG_ERROR      = errors.TN(SPIRIT_ERR_NS, 16, "delete message error, type: {{.type}}, url: {{.url}}, err: {{.err}}")
	ERR_RECEIVER_UNMARSHAL_MSG_FAILED  = errors.TN(SPIRIT_ERR_NS, 17, "receiver unmarshal message failed, type: {{.type}}, err: {{.err}}")
	ERR_RECEIVER_RECV_ERROR            = errors.TN(SPIRIT_ERR_NS, 18, "receiver recv error, type: {{.type}}, url: {{.url}}, err: {{.err}}")
	ERR_RECEIVER_BAD_DRIVER            = errors.TN(SPIRIT_ERR_NS, 19, "bad message receiver driver of {{.type}}")
	ERR_RECEIVER_CREATE_FAILED         = errors.TN(SPIRIT_ERR_NS, 20, "create receiver failed, driver type: {{.type}}, url: {{.url}}")
	ERR_RECEIVER_DRIVER_NOT_EXIST      = errors.TN(SPIRIT_ERR_NS, 21, "message receiver driver not exist, type: {{.type}}")
	ERR_RECEIVER_DECODE_MESSAGE_FAILED = errors.TN(SPIRIT_ERR_NS, 22, "message receiver decode message failed, type: {{.type}}, url: {{.url}}, err: {{.err}}")

	ERR_PORT_NAME_IS_EMPTY    = errors.TN(SPIRIT_ERR_NS, 23, "port name is empty, component: {{.name}}")
	ERR_HANDLER_NAME_IS_EMPTY = errors.TN(SPIRIT_ERR_NS, 24, "handler name is empty, component: {{.name}}")

	ERR_UUID_GENERATE_FAILED = errors.TN(SPIRIT_ERR_NS, 26, "uuid generate failed, err: {{.err}}")

	ERR_PAYLOAD_GO_BAD           = errors.TN(SPIRIT_ERR_NS, 27, "payload go bad, err: {{.err}}")
	ERR_PAYLOAD_SERIALIZE_FAILED = errors.TN(SPIRIT_ERR_NS, 28, "payload serialize failed, err: {{.err}}")

	ERR_COMPONENT_HANDLER_PANIC = errors.TN(SPIRIT_ERR_NS, 29, "component handler panic,component: {{.name}}, err: {{.err}}")

	ERR_HEARTBEAT_OPTIONS_IS_NIL = errors.TN(SPIRIT_ERR_NS, 30, "heartbeat options is nil, heartbeat name: {{.name}}")

	ERR_READE_FILE_ERROR     = errors.TN(SPIRIT_ERR_NS, 31, "read file error,file: {{.file}} err: {{.err}}")
	ERR_UNMARSHAL_DATA_ERROR = errors.TN(SPIRIT_ERR_NS, 32, "unmarshal data error, err: {{.err}}")

	ERR_HEARTBEAT_ALI_JIANKONG_UID_NOT_EXIST = errors.TN(SPIRIT_ERR_NS, 33, "heartbeat of ali jiankong's uid does not exist")

	ERR_HOOK_CREATE_FAILED             = errors.TN(SPIRIT_ERR_NS, 34, "create receiver failed, driver type: {{.type}}, name: {{.name}}")
	ERR_HOOK_DRIVER_NOT_EXIST          = errors.TN(SPIRIT_ERR_NS, 35, "message hook driver not exist, type: {{.type}}")
	ERR_HOOK_BAD_DRIVER                = errors.TN(SPIRIT_ERR_NS, 36, "bad message hook driver of {{.type}}")
	ERR_MESSAGE_HOOK_ERROR             = errors.TN(SPIRIT_ERR_NS, 37, "hook message error, component: {{.name}}, port: {{.port}}, hookName: {{.hookName}}, event: {{.event}}, index: {{.index}}/{{.count}}")
	ERR_HOOK_INSTANCE_ALREADY_INITALED = errors.TN(SPIRIT_ERR_NS, 38, "hook instance already initaled, driver type: {{.type}}, name: {{.name}}")
	ERR_HOOK_INSTANCE_NOT_INITALED     = errors.TN(SPIRIT_ERR_NS, 39, "hook instance not initaled, hook name: {{.name}}")
	ERR_INPORT_NOT_BIND_HOOK           = errors.TN(SPIRIT_ERR_NS, 40, "in port of {{.inPortName}} not bind hooks")
	ERR_HOOK_BIG_DATA_OPEN_FILE        = errors.TN(SPIRIT_ERR_NS, 41, "open file error,{{.err}}")
	ERR_HOOK_BIG_DATA_UNMARSHAL_CONF   = errors.TN(SPIRIT_ERR_NS, 42, "envJson unmarshal config error,{{.err}}")
	ERR_HOOK_BIG_DATA_CREATE_REDIS     = errors.TN(SPIRIT_ERR_NS, 43, "create redis error,{{.err}}")
	ERR_HOOK_BIG_DATA_REDIS_GET        = errors.TN(SPIRIT_ERR_NS, 44, "redis get data error,{{.err}}")
	ERR_HOOK_BIG_DATA_REDIS_SET        = errors.TN(SPIRIT_ERR_NS, 45, "redis set data error,{{.err}}")
	ERR_JSON_UNMARSHAL                 = errors.TN(SPIRIT_ERR_NS, 46, "json unmarshal data error,{{.err}}")
	ERR_JSON_MARSHAL                   = errors.TN(SPIRIT_ERR_NS, 47, "json marshal data error,{{.err}}")
	ERR_HOOK_NAME_IS_EMPTY             = errors.TN(SPIRIT_ERR_NS, 48, "hook name is empty")
	ERR_HOOK_DRIVER_TYPE_IS_EMPTY      = errors.TN(SPIRIT_ERR_NS, 49, "hook driver type is empty")
	ERR_HEARTBEAT_NOT_EXIST            = errors.TN(SPIRIT_ERR_NS, 50, "heartbeat of {{.name}} not exist")
	ERR_OPTIONS_KEY_NOT_EXIST          = errors.TN(SPIRIT_ERR_NS, 51, "options key of {{.key}} not exist")
	ERR_OPTIONS_VALUE_TYPE_ERROR       = errors.TN(SPIRIT_ERR_NS, 52, "the key of {{.key}}'s value is {{.value}}, but it was not a type of {{.type}}, the real type was {{.realType}}")
	ERR_ASSET_FILE_NOT_CACHED          = errors.TN(SPIRIT_ERR_NS, 53, "asset file of {{.fileName}} not cached")
	ERR_ASSET_ALREADY_LOADED           = errors.TN(SPIRIT_ERR_NS, 54, "asset file already loaded, but did not have same md5: {{.fileName}}")
	ERR_CACHE_FILE_NOT_SPECIFIC        = errors.TN(SPIRIT_ERR_NS, 55, "cache file not specific")
	ERR_CACHE_FILE_LOAD_FAILED         = errors.TN(SPIRIT_ERR_NS, 56, "load cache file failed, file: {{.fileName}}, err: {{.err}}")
	ERR_CACHE_ASSET_BACKUP_FAILED      = errors.TN(SPIRIT_ERR_NS, 57, "backup cache asset failed, file: {{.fileName}}, err: {{.err}}")
	ERR_CACHE_FILE_COULD_NOT_SAVE      = errors.TN(SPIRIT_ERR_NS, 58, "cache file could not save,file: {{.fileName}}, err: {{.err}}")
	ERR_CACHE_FILE_SERIALIZE_FAILED    = errors.TN(SPIRIT_ERR_NS, 59, "cache file serialize failed, file: {{.fileName}}, err: {{.err}}")
	ERR_INSTANCE_HOME_CREATE_FAILED    = errors.TN(SPIRIT_ERR_NS, 60, "could not create instance home: {{.dir}}")
	ERR_SAVE_INSTANCE_METADATA_FAILED  = errors.TN(SPIRIT_ERR_NS, 61, "save instance metadata failed, instance: {{.name}}, err: {{.err}}")
	ERR_INSTANCE_NAME_IS_EMPTY         = errors.TN(SPIRIT_ERR_NS, 62, "instance name is empty")
	ERR_LOAD_INSTANCE_METADATA_FAILED  = errors.TN(SPIRIT_ERR_NS, 63, "load instance metadata failed, you may need recreate the spirit instance, instance: {{.name}}, err: {{.err}}")
	ERR_INSTANCE_CAN_NOT_DEL_WHILE_RUN = errors.TN(SPIRIT_ERR_NS, 64, "instance of {{.name}} cloud not delete while running, running pid: {{.pid}}")
	ERR_OPTIONS_VAL_TYPE_CONV_FAILED   = errors.TN(SPIRIT_ERR_NS, 65, "the key of {{.key}}'s value is {{.value}}, but it was not a type of {{.type}}, and convert it from {{.realType}} failed, err: {{.err}}")
	ERR_INSTANCE_HASH_IS_EMPTY         = errors.TN(SPIRIT_ERR_NS, 66, "the instance of {{.name}} hash is empty, you may recreate this instance")
	ERR_INSTANCE_BIN_ALREADY_COMMIT    = errors.TN(SPIRIT_ERR_NS, 67, "instance of {{.name}} already commited, hash: {{.hash}}")
	ERR_GET_INSTNACE_COMMIT_INFO_ERROR = errors.TN(SPIRIT_ERR_NS, 68, "get instance of {{.name}} commit info error, err: {{.err}}")
	ERR_WRITE_COMMIT_MESSAGE_ERROR     = errors.TN(SPIRIT_ERR_NS, 69, "write commit message error: {{.err}}")
	ERR_MUST_CHECKOUT_BEFORE_REMOVE    = errors.TN(SPIRIT_ERR_NS, 70, "cloud not remove the binary with hash {{.hash}} while using, you can checkout other's bin before remove")
	ERR_REMOVE_BIN_ERROR               = errors.TN(SPIRIT_ERR_NS, 71, "remove binary with hash {{.hash}} failed, err: {{.err}}")
	ERR_COULD_NOT_MAKE_SPIRIT_TMP_DIR  = errors.TN(SPIRIT_ERR_NS, 72, "could not make tmp dir, error: {{.err}}")
	ERR_WRITE_TMP_CONFIG_FILE_FAILED   = errors.TN(SPIRIT_ERR_NS, 73, "write tmp config of {{.fileName}} failed, err: {{.err}}")
	ERR_MARSHAL_CONFIG_FAILED          = errors.TN(SPIRIT_ERR_NS, 74, "marshal config of {{.fileName}} failed, err: {{.err}}")
	ERR_GET_FILE_REL_PATH_FAILED       = errors.TN(SPIRIT_ERR_NS, 75, "get file of {{.fileName}} 's rel path failed, err: {{.err}}")
	ERR_GET_FILE_ABS_PATH_FAILED       = errors.TN(SPIRIT_ERR_NS, 76, "get file of {{.fileName}} 's abs path failed, err: {{.err}}")

	ERR_SPIRIT_NO_CONFIG_SPECIFIC        = errors.TN(SPIRIT_ERR_NS, 1000, "no config file specific")
	ERR_SPIRIT_ENV_FORAMT_ERROR          = errors.TN(SPIRIT_ERR_NS, 1002, "env format error: {{.env}}")
	ERR_SPIRIT_NO_COMPONENTS_TO_RUN      = errors.TN(SPIRIT_ERR_NS, 1003, "no components to run")
	ERR_SPIRIT_COMPONENT_NOT_HOSTING     = errors.TN(SPIRIT_ERR_NS, 1004, "component not hosting: {{.name}}")
	ERR_SPIRIT_COMPONENT_CONF_NOT_EXIST  = errors.TN(SPIRIT_ERR_NS, 1005, "component of {{.name}} did not have configuare in config file")
	ERR_SPIRIT_COMPONENT_CONF_DUP        = errors.TN(SPIRIT_ERR_NS, 1006, "component of {{.name}}'s config duplicated")
	ERR_SPIRIT_SPIRIT_DID_NOT_BUILD      = errors.TN(SPIRIT_ERR_NS, 1007, "spirit did not build")
	ERR_SPIRIT_LOAD_COMPONENT_CONF_ERROR = errors.TN(SPIRIT_ERR_NS, 1008, "load component config error, file: {{.fileName}}, error: {{.err}}")
	ERR_SPIRIT_WRITE_PID_FILE_ERROR      = errors.TN(SPIRIT_ERR_NS, 1009, "write pid file error: {{.err}}")
	ERR_SPIRIT_GET_INSTANCE_PID_FAILED   = errors.TN(SPIRIT_ERR_NS, 1010, "get instance pid of {{.name}} failed, err: {{.err}}")
	ERR_SPIRIT_LIST_INSTANCE_FAILED      = errors.TN(SPIRIT_ERR_NS, 1011, "list instances failed, err: {{.err}}")
	ERR_SPIRIT_READ_PID_FILE_ERROR       = errors.TN(SPIRIT_ERR_NS, 1012, "read instance of {{.name}} pid file error: {{.err}}")
	ERR_SPIRIT_LOCK_PID_FILE_FAILED      = errors.TN(SPIRIT_ERR_NS, 1013, "lock instance pid file failed, instacne: {{.name}}, {{.err}}")
	ERR_SPIRIT_INSTANCE_NAME_NOT_INPUT   = errors.TN(SPIRIT_ERR_NS, 1014, "please input instance name")
	ERR_SPIRIT_ONLY_ONE_INST_NAME        = errors.TN(SPIRIT_ERR_NS, 1015, "only one instance name allowed")
	ERR_SPIRIT_INSTANCE_ALREADY_CREATED  = errors.TN(SPIRIT_ERR_NS, 1016, "the same instance of [{{.name}}] already created, please use start command.")
	ERR_SPIRIT_REMOVE_INSTANCE_FAILED    = errors.TN(SPIRIT_ERR_NS, 1017, "remove spirit instance of [{{.name}}] error: {{.err}}")
	ERR_SPIRIT_INSTANCE_NOT_EXIST        = errors.TN(SPIRIT_ERR_NS, 1018, "spirit instance of {{.name}} not exist")
	ERR_SPIRIT_STOP_INSTANCE_FIALED      = errors.TN(SPIRIT_ERR_NS, 1019, "stop instance of {{.name}} failed, running pid: {{.pid}}, err: {{.err}}")
	ERR_SPIRIT_KILL_INSTANCE_FIALED      = errors.TN(SPIRIT_ERR_NS, 1020, "kill instance of {{.name}} failed, running pid: {{.pid}}, err: {{.err}}")
	ERR_SPIRIT_PAUSE_INSTANCE_FIALED     = errors.TN(SPIRIT_ERR_NS, 1021, "pause or resume instance of {{.name}} failed, running pid: {{.pid}}, err: {{.err}}")
	ERR_SPIRIT_INSTANCE_NOT_RUNNING      = errors.TN(SPIRIT_ERR_NS, 1022, "instance of {{.name}} may not running.")
	ERR_SPIRIT_COPY_INSTANCE_ERROR       = errors.TN(SPIRIT_ERR_NS, 1023, "copy instance error, err: {{.err}}")
	ERR_SPIRIT_START_CHILD_INSTANCE      = errors.TN(SPIRIT_ERR_NS, 1024, "start child instance of {{.name}} failed, err: {{.err}}")
	ERR_SPIRIT_COMMIT_MSG_NOT_INPUT      = errors.TN(SPIRIT_ERR_NS, 1025, "commit message not input")
	ERR_SPIRIT_INSTANCE_HASH_NOT_INPUT   = errors.TN(SPIRIT_ERR_NS, 1026, "spirit instance hash not input")
)
View Source 
var (
	Assets *assetsManager = newAssetsManager("")
)
View Source 
var (
	EventCenter event_center.EventCenter = event_center.NewClassicEventCenter(SPIRIT)
)

Functions

func RegisterHeartbeaters added in v0.2.0 

func RegisterHeartbeaters(beaters ...Heartbeater)

func RegisterMessageHooks added in v0.3.4 

func RegisterMessageHooks(hooks ...MessageHook)

func RegisterMessageReceivers added in v0.3.4 

func RegisterMessageReceivers(receivers ...MessageReceiver)

func RegisterMessageSenders added in v0.3.4 

func RegisterMessageSenders(senders ...MessageSender)

func RemoveHeartBeaters added in v0.2.0 

func RemoveHeartBeaters(names ...string)

func SetMessageHookFactory added in v0.2.0 

func SetMessageHookFactory(factory MessageHookFactory)

func SetMessageReceiverFactory added in v0.2.0 

func SetMessageReceiverFactory(factory MessageReceiverFactory)

func SetMessageSenderFactory added in v0.2.0 

func SetMessageSenderFactory(factory MessageSenderFactory)

Types

type AliJiankong 

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

func (*AliJiankong) Heartbeat 

func (p *AliJiankong) Heartbeat(heartbeatMessage HeartbeatMessage)

func (*AliJiankong) Name 

func (p *AliJiankong) Name() string

func (*AliJiankong) Start 

func (p *AliJiankong) Start(options Options) (err error)

type AssetProperty added in v0.2.0 

type AssetProperty struct {
	FileName  string `json:"file"`
	NeedBuild bool   `json:"env_build"`
}

type Author added in v0.2.0 

type Author struct {
	Name  string
	Email string
}

type BaseComponent 

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

func (*BaseComponent) AddInPortHooks 

func (p *BaseComponent) AddInPortHooks(inportName string, hooks ...string) Component

func (*BaseComponent) BindHandler 

func (p *BaseComponent) BindHandler(inPortName, handlerName string) Component

func (*BaseComponent) BindReceiver 

func (p *BaseComponent) BindReceiver(inPortName string, receivers ...MessageReceiver) Component

func (*BaseComponent) Build 

func (p *BaseComponent) Build() Component

func (*BaseComponent) CallHandler 

func (p *BaseComponent) CallHandler(handlerName string, payload *Payload) (result interface{}, err error)

func (*BaseComponent) ClearInPortHooks 

func (p *BaseComponent) ClearInPortHooks(inportName string) (err error)

func (*BaseComponent) GetHandlers 

func (p *BaseComponent) GetHandlers(handlerNames ...string) (handlers map[string]ComponentHandler, err error)

func (*BaseComponent) GetReceivers 

func (p *BaseComponent) GetReceivers(inPortName string) []MessageReceiver

func (*BaseComponent) ListHandlers 

func (p *BaseComponent) ListHandlers() (handlers map[string]ComponentHandler, err error)

func (*BaseComponent) Name 

func (p *BaseComponent) Name() string

func (*BaseComponent) Pause added in v0.3.0 

func (p *BaseComponent) Pause()

func (*BaseComponent) RegisterHandler 

func (p *BaseComponent) RegisterHandler(name string, handler ComponentHandler) Component

func (*BaseComponent) Resume added in v0.3.0 

func (p *BaseComponent) Resume()

func (*BaseComponent) Run 

func (p *BaseComponent) Run()

func (*BaseComponent) Status 

func (p *BaseComponent) Status() ComponentStatus

func (*BaseComponent) Stop 

func (p *BaseComponent) Stop()

type ChanStatistics added in v0.3.0 

type ChanStatistics struct {
	Name string
	Len  int
	Cap  int
}

type ClassicSpirit 

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

func (*ClassicSpirit) Build 

func (p *ClassicSpirit) Build() Spirit

func (*ClassicSpirit) Hosting 

func (p *ClassicSpirit) Hosting(component Component, initalFuncs ...InitalFunc) Spirit

func (*ClassicSpirit) Run 

func (p *ClassicSpirit) Run()

type Component 

type Component interface {
	Name() string

	BindHandler(inPortName string, handlerName string) Component
	RegisterHandler(name string, handler ComponentHandler) Component
	CallHandler(handlerName string, payload *Payload) (result interface{}, err error)

	AddInPortHooks(inportName string, hooks ...string) Component
	ClearInPortHooks(inportName string) (err error)

	ListHandlers() (handlers map[string]ComponentHandler, err error)
	GetHandlers(handlerNames ...string) (handlers map[string]ComponentHandler, err error)

	BindReceiver(inPortName string, receivers ...MessageReceiver) Component
	GetReceivers(inPortName string) []MessageReceiver

	Build() Component
	Run()

	Pause()
	Resume()
	Stop()

	Status() ComponentStatus
}

func NewBaseComponent 

func NewBaseComponent(componentName string) Component

type ComponentCommands 

type ComponentCommands map[string][]interface{}

type ComponentContext 

type ComponentContext map[string]interface{}

type ComponentHandler 

type ComponentHandler func(payload *Payload) (result interface{}, err error)

type ComponentMessage 

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

func NewComponentMessage 

func NewComponentMessage(graph MessageGraph, payload Payload) (message ComponentMessage, err error)

func (*ComponentMessage) Id 

func (p *ComponentMessage) Id() string

func (*ComponentMessage) Serialize 

func (p *ComponentMessage) Serialize() (data []byte, err error)

func (*ComponentMessage) UnSerialize 

func (p *ComponentMessage) UnSerialize(data []byte) (err error)

type ComponentStatus 

type ComponentStatus int

type DefaultMessageHookFactory 

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

func (*DefaultMessageHookFactory) CreateHook added in v0.2.0 

func (p *DefaultMessageHookFactory) CreateHook(hookType, name string, options Options) (hook MessageHook, err error)

func (*DefaultMessageHookFactory) Get 

func (p *DefaultMessageHookFactory) Get(name string) (hook MessageHook, err error)

func (*DefaultMessageHookFactory) IsExist 

func (p *DefaultMessageHookFactory) IsExist(hookType string) bool

func (*DefaultMessageHookFactory) RegisterMessageHooks 

func (p *DefaultMessageHookFactory) RegisterMessageHooks(hooks ...MessageHook)

type DefaultMessageReceiverFactory 

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

func (*DefaultMessageReceiverFactory) IsExist 

func (p *DefaultMessageReceiverFactory) IsExist(receiverType string) bool

func (*DefaultMessageReceiverFactory) NewReceiver 

func (p *DefaultMessageReceiverFactory) NewReceiver(receiverType, url string, options Options) (receiver MessageReceiver, err error)

func (*DefaultMessageReceiverFactory) RegisterMessageReceivers 

func (p *DefaultMessageReceiverFactory) RegisterMessageReceivers(receivers ...MessageReceiver)

type DefaultMessageSenderFactory 

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

func (*DefaultMessageSenderFactory) IsExist 

func (p *DefaultMessageSenderFactory) IsExist(senderType string) bool

func (*DefaultMessageSenderFactory) NewSender 

func (p *DefaultMessageSenderFactory) NewSender(senderType string) (sender MessageSender, err error)

func (*DefaultMessageSenderFactory) RegisterMessageSenders 

func (p *DefaultMessageSenderFactory) RegisterMessageSenders(senders ...MessageSender)

type Error 

type Error struct {
	Id         string                 `json:"id,omitempty"`
	Namespace  string                 `json:"namespace,omitempty"`
	Code       uint64                 `json:"code,omitempty"`
	AddressId  int32                  `json:"address_id,omitempty"`
	Message    string                 `json:"message,omitempty"`
	Context    map[string]interface{} `json:"context,omitempty"`
	StackTrace string                 `json:"stack_trace,omitempty"`
}

type HeartbeatMessage 

type HeartbeatMessage struct {
	PID            int
	HostName       string
	InstanceName   string
	StartTime      time.Time
	CurrentTime    time.Time
	HeartbeatCount int64
}

type Heartbeater 

type Heartbeater interface {
	Name() string
	Start(options Options) error
	Heartbeat(heartbeatMessage HeartbeatMessage)
}

type HookEvent 

type HookEvent int32
const (
	HookEventBeforeCallHandler HookEvent = 1
	HookEventAfterCallHandler  HookEvent = 2
)

type InitalFunc 

type InitalFunc func() (err error)

type MessageAddress 

type MessageAddress struct {
	Type string `json:"type"`
	Url  string `json:"url"`
}

type MessageGraph 

type MessageGraph map[string]MessageAddress

func (MessageGraph) AddAddress 

func (p MessageGraph) AddAddress(addrs ...MessageAddress) int

func (MessageGraph) AddAddressToHead added in v0.3.4 

func (p MessageGraph) AddAddressToHead(addrs ...MessageAddress) int

func (MessageGraph) ClearErrorAddress 

func (p MessageGraph) ClearErrorAddress()

func (MessageGraph) SetErrorAddress 

func (p MessageGraph) SetErrorAddress(address MessageAddress)

type MessageHook 

type MessageHook interface {
	Init(options Options) error
	Name() string
	HookBefore(
		currentMetadata MessageHookMetadata,
		previousMetadatas []MessageHookMetadata,
		contextMetadatas []MessageHookMetadata,
		payload *Payload) (ignored bool, newMetaData MessageHookMetadata, err error)

	HookAfter(
		previousMetadatas []MessageHookMetadata,
		contextMetadatas []MessageHookMetadata,
		payload *Payload) (ignored bool, newMetaData MessageHookMetadata, err error)
}

type MessageHookBigDataRedis 

type MessageHookBigDataRedis struct{}

func (*MessageHookBigDataRedis) HookAfter 

func (p *MessageHookBigDataRedis) HookAfter(
	previousMetadatas []MessageHookMetadata,
	contextMetadatas []MessageHookMetadata,
	payload *Payload) (ignored bool, newMetaData MessageHookMetadata, err error)

func (*MessageHookBigDataRedis) HookBefore 

func (p *MessageHookBigDataRedis) HookBefore(
	currentMetadata MessageHookMetadata,
	previousMetadatas []MessageHookMetadata,
	contextMetadatas []MessageHookMetadata,
	payload *Payload) (ignored bool, newMetaData MessageHookMetadata, err error)

func (*MessageHookBigDataRedis) Init 

func (p *MessageHookBigDataRedis) Init(options Options) (err error)

func (*MessageHookBigDataRedis) Name 

func (p *MessageHookBigDataRedis) Name() string

type MessageHookFactory 

type MessageHookFactory interface {
	RegisterMessageHooks(hooks ...MessageHook)
	IsExist(hookType string) bool
	CreateHook(hookType, name string, options Options) (hook MessageHook, err error)
	Get(name string) (hook MessageHook, err error)
}

func GetMessageHookFactory added in v0.2.0 

func GetMessageHookFactory() MessageHookFactory

func NewDefaultMessageHookFactory 

func NewDefaultMessageHookFactory() MessageHookFactory

type MessageHookMetadata 

type MessageHookMetadata struct {
	HookName string                 `json:"hook_name"`
	Context  map[string]interface{} `json:"context"`
}

type MessageReceiver 

type MessageReceiver interface {
	Type() string
	Init(url string, options Options) error
	Address() MessageAddress
	BindInPort(
		componentName, inPortName string,
		onMsgReceived OnReceiverMessageReceived,
		onReceiverError OnReceiverError)
	Start()
	Stop()
	IsRunning() bool
	Metadata() ReceiverMetadata
}

func NewMessageReceiverMNS added in v0.3.0 

func NewMessageReceiverMNS(url string) MessageReceiver

type MessageReceiverFactory 

type MessageReceiverFactory interface {
	RegisterMessageReceivers(receivers ...MessageReceiver)
	IsExist(receiverType string) bool
	NewReceiver(receiverType, url string, options Options) (receiver MessageReceiver, err error)
}

func GetMessageReceiverFactory added in v0.2.0 

func GetMessageReceiverFactory() MessageReceiverFactory

func NewDefaultMessageReceiverFactory 

func NewDefaultMessageReceiverFactory() MessageReceiverFactory

type MessageReceiverMNS added in v0.3.0 

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

func (*MessageReceiverMNS) Address added in v0.3.0 

func (p *MessageReceiverMNS) Address() MessageAddress

func (*MessageReceiverMNS) BindInPort added in v0.3.0 

func (p *MessageReceiverMNS) BindInPort(componentName, inPortName string, onMsgReceived OnReceiverMessageReceived, onReceiverError OnReceiverError)

func (*MessageReceiverMNS) Init added in v0.3.0 

func (p *MessageReceiverMNS) Init(url string, options Options) (err error)

func (*MessageReceiverMNS) IsRunning added in v0.3.0 

func (p *MessageReceiverMNS) IsRunning() bool

func (*MessageReceiverMNS) Metadata added in v0.3.0 

func (p *MessageReceiverMNS) Metadata() ReceiverMetadata

func (*MessageReceiverMNS) Start added in v0.3.0 

func (p *MessageReceiverMNS) Start()

func (*MessageReceiverMNS) Stop added in v0.3.0 

func (p *MessageReceiverMNS) Stop()

func (*MessageReceiverMNS) Type added in v0.3.0 

func (p *MessageReceiverMNS) Type() string

type MessageReceiverMQS 

type MessageReceiverMQS struct {
	MessageReceiverMNS
}

func (*MessageReceiverMQS) Type 

func (p *MessageReceiverMQS) Type() string

type MessageSender 

type MessageSender interface {
	Type() string
	Init() error
	Send(url string, message ComponentMessage) (err error)
}

func NewMessageSenderMNS added in v0.3.0 

func NewMessageSenderMNS() MessageSender

type MessageSenderFactory 

type MessageSenderFactory interface {
	RegisterMessageSenders(senders ...MessageSender)
	IsExist(senderType string) bool
	NewSender(senderType string) (sender MessageSender, err error)
}

func GetMessageSenderFactory added in v0.2.0 

func GetMessageSenderFactory() MessageSenderFactory

func NewDefaultMessageSenderFactory 

func NewDefaultMessageSenderFactory() MessageSenderFactory

type MessageSenderMNS added in v0.3.0 

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

func (*MessageSenderMNS) Init added in v0.3.0 

func (p *MessageSenderMNS) Init() (err error)

func (*MessageSenderMNS) Send added in v0.3.0 

func (p *MessageSenderMNS) Send(url string, message ComponentMessage) (err error)

func (*MessageSenderMNS) Type added in v0.3.0 

func (p *MessageSenderMNS) Type() string

type MessageSenderMQS 

type MessageSenderMQS struct {
	MessageSenderMNS
}

func (*MessageSenderMQS) Type 

func (p *MessageSenderMQS) Type() string

type OnReceiverError added in v0.3.0 

type OnReceiverError func(inPortName string, err error)

type OnReceiverMessageProcessed added in v0.3.0 

type OnReceiverMessageProcessed func(context interface{})

type OnReceiverMessageReceived added in v0.3.0 

type OnReceiverMessageReceived func(inPortName string, context interface{}, compMsg ComponentMessage, callbacks ...OnReceiverMessageProcessed)

type Options added in v0.2.0 

type Options map[string]interface{}

func (Options) GetBoolValue added in v0.3.2 

func (p Options) GetBoolValue(key string) (value bool, err error)

func (Options) GetFloat64Value added in v0.2.0 

func (p Options) GetFloat64Value(key string) (value float64, err error)

func (Options) GetInt64Value added in v0.2.0 

func (p Options) GetInt64Value(key string) (value int64, err error)

func (Options) GetStringValue added in v0.2.0 

func (p Options) GetStringValue(key string) (value string, err error)

func (Options) Serialize added in v0.2.0 

func (p Options) Serialize() (str string, err error)

type Payload 

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

func (*Payload) AppendCommand 

func (p *Payload) AppendCommand(command string, value interface{})

func (*Payload) CopyFrom 

func (p *Payload) CopyFrom(payload *Payload)

func (*Payload) Error 

func (p *Payload) Error() Error

func (*Payload) FillContentToObject 

func (p *Payload) FillContentToObject(v interface{}) (err error)

func (*Payload) GetCommand 

func (p *Payload) GetCommand(key string) (val []interface{}, exist bool)

func (*Payload) GetCommandObjectArray 

func (p *Payload) GetCommandObjectArray(command string, values []interface{}) (err error)

func (*Payload) GetCommandStringArray 

func (p *Payload) GetCommandStringArray(command string) (vals []string, err error)

func (*Payload) GetCommandValueSize 

func (p *Payload) GetCommandValueSize(key string) int

func (*Payload) GetContent 

func (p *Payload) GetContent() interface{}

func (*Payload) GetContext 

func (p *Payload) GetContext(key string) (val interface{}, exist bool)

func (*Payload) GetContextInt 

func (p *Payload) GetContextInt(key string) (val int, err error)

func (*Payload) GetContextInt32 

func (p *Payload) GetContextInt32(key string) (val int32, err error)

func (*Payload) GetContextInt64 

func (p *Payload) GetContextInt64(key string) (val int64, err error)

func (*Payload) GetContextObject 

func (p *Payload) GetContextObject(key string, v interface{}) (err error)

func (*Payload) GetContextString 

func (p *Payload) GetContextString(key string) (val string, err error)

func (*Payload) GetContextStringArray 

func (p *Payload) GetContextStringArray(key string) (vals []string, err error)

func (*Payload) GoBad 

func (p *Payload) GoBad(e error)

func (*Payload) Id 

func (p *Payload) Id() string

func (*Payload) IsCorrect 

func (p *Payload) IsCorrect() bool

func (*Payload) Serialize 

func (p *Payload) Serialize() (data []byte, err error)

func (*Payload) SetCommand 

func (p *Payload) SetCommand(command string, values []interface{})

func (*Payload) SetContent 

func (p *Payload) SetContent(content interface{})

func (*Payload) SetContext 

func (p *Payload) SetContext(key string, val interface{})

func (*Payload) UnSerialize 

func (p *Payload) UnSerialize(data []byte) (err error)

type ReceiverMetadata added in v0.3.0 

type ReceiverMetadata struct {
	ComponentName string
	PortName      string
	Type          string
}

type Spirit 

type Spirit interface {
	Hosting(component Component, initalFuncs ...InitalFunc) Spirit
	Build() Spirit
	Run()
}

func NewClassicSpirit 

func NewClassicSpirit(name, description, version string, authors []Author) Spirit

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.