spirit

package module

Go to main page

Versions in this module

v0

v0.3.4

Mar 6, 2017

Changes in this version

+ const REDIS_DATA_SIZE

+ func RegisterMessageHooks(hooks ...MessageHook)

+ func RegisterMessageReceivers(receivers ...MessageReceiver)

+ func RegisterMessageSenders(senders ...MessageSender)

type Error

+ Context map[string]interface{}

+ StackTrace string

type MessageGraph

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

v0.3.3

Oct 20, 2015

v0.3.2

Oct 14, 2015

Changes in this version

type Options

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

v0.3.1

Oct 10, 2015

Changes in this version

+ type ReceiverProcessMode string

+ const ConcurrencyMode

+ const SequencyMode

v0.3.0

Oct 9, 2015

Changes in this version

+ const EVENT_AFTER_MESSAGE_HOOK

+ const EVENT_AFTER_MESSAGE_SEND

+ const EVENT_BASE_COMPONENT_INTERNAL_MESSAGE

+ const EVENT_BASE_COMPONENT_STOPPED

+ const EVENT_BASE_COMPONENT_STOPPING

+ const EVENT_BEFORE_MESSAGE_HOOK

+ const EVENT_BEFORE_MESSAGE_SEND

+ const EVENT_CMD_STOP

+ const EVENT_HEARTBEAT

+ const EVENT_RECEIVER_MSG_COUNT_UPDATED

+ const EVENT_RECEIVER_MSG_DELETED

+ const EVENT_RECEIVER_MSG_ERROR

+ const EVENT_RECEIVER_MSG_RECEIVED

+ const EVENT_RECEIVER_STARTED

+ const EVENT_RECEIVER_STOPPED

+ const STATUS_STOPPED

+ var ERR_RECEIVER_MNS_CLIENT_IS_NIL = errors.TN(SPIRIT_ERR_NS, 15, ...)

+ var ERR_SENDER_MNS_CLIENT_IS_NIL = errors.TN(SPIRIT_ERR_NS, 9, "sender mns client is nil, type: {{.type}}, url: {{.url}}")

+ var EventCenter event_center.EventCenter = event_center.NewClassicEventCenter(SPIRIT)

type BaseComponent

+ func (p *BaseComponent) Pause()

+ func (p *BaseComponent) Resume()

+ type ChanStatistics struct

+ Cap int

+ Len int

+ Name string

type Component

+ Pause func()

+ Resume func()

type MessageReceiver

+ func NewMessageReceiverMNS(url string) MessageReceiver

+ BindInPort func(componentName, inPortName string, onMsgReceived OnReceiverMessageReceived, ...)

+ IsRunning func() bool

+ Metadata func() ReceiverMetadata

+ Start func()

+ Stop func()

+ type MessageReceiverMNS struct

+ func (p *MessageReceiverMNS) Address() MessageAddress

+ func (p *MessageReceiverMNS) BindInPort(componentName, inPortName string, onMsgReceived OnReceiverMessageReceived, ...)

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

+ func (p *MessageReceiverMNS) IsRunning() bool

+ func (p *MessageReceiverMNS) Metadata() ReceiverMetadata

+ func (p *MessageReceiverMNS) Start()

+ func (p *MessageReceiverMNS) Stop()

+ func (p *MessageReceiverMNS) Type() string

type MessageSender

+ func NewMessageSenderMNS() MessageSender

+ type MessageSenderMNS struct

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

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

+ func (p *MessageSenderMNS) Type() string

+ type OnReceiverError func(inPortName string, err error)

+ type OnReceiverMessageProcessed func(context interface{})

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

+ type ReceiverMetadata struct

+ ComponentName string

+ PortName string

+ Type string

v0.2.1

Jun 8, 2015

v0.2.0

Jun 5, 2015

Changes in this version

+ const FILE_CHUNK

+ const INSTANCE_EXITED

+ const INSTANCE_RUNNING

+ const SPIRIT_BIN_HOME

+ const SPIRIT_CHILD_INSTANCE

+ var Assets *assetsManager = newAssetsManager("")

+ var ERR_ASSET_ALREADY_LOADED = errors.TN(SPIRIT_ERR_NS, 54, ...)

+ var ERR_ASSET_FILE_NOT_CACHED = errors.TN(SPIRIT_ERR_NS, 53, "asset file of {{.fileName}} not cached")

+ var ERR_CACHE_ASSET_BACKUP_FAILED = errors.TN(SPIRIT_ERR_NS, 57, ...)

+ var ERR_CACHE_FILE_COULD_NOT_SAVE = errors.TN(SPIRIT_ERR_NS, 58, ...)

+ var ERR_CACHE_FILE_LOAD_FAILED = errors.TN(SPIRIT_ERR_NS, 56, ...)

+ var ERR_CACHE_FILE_NOT_SPECIFIC = errors.TN(SPIRIT_ERR_NS, 55, "cache file not specific")

+ var ERR_CACHE_FILE_SERIALIZE_FAILED = errors.TN(SPIRIT_ERR_NS, 59, ...)

+ var ERR_COULD_NOT_MAKE_SPIRIT_TMP_DIR = errors.TN(SPIRIT_ERR_NS, 72, "could not make tmp dir, error: {{.err}}")

+ var ERR_GET_FILE_ABS_PATH_FAILED = errors.TN(SPIRIT_ERR_NS, 76, ...)

+ var ERR_GET_FILE_REL_PATH_FAILED = errors.TN(SPIRIT_ERR_NS, 75, ...)

+ var ERR_GET_INSTNACE_COMMIT_INFO_ERROR = errors.TN(SPIRIT_ERR_NS, 68, ...)

+ var ERR_HEARTBEAT_NOT_EXIST = errors.TN(SPIRIT_ERR_NS, 50, "heartbeat of {{.name}} not exist")

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

+ var ERR_HOOK_DRIVER_TYPE_IS_EMPTY = errors.TN(SPIRIT_ERR_NS, 49, "hook driver type is empty")

+ var ERR_HOOK_NAME_IS_EMPTY = errors.TN(SPIRIT_ERR_NS, 48, "hook name is empty")

+ var ERR_INSTANCE_BIN_ALREADY_COMMIT = errors.TN(SPIRIT_ERR_NS, 67, "instance of {{.name}} already commited, hash: {{.hash}}")

+ var ERR_INSTANCE_CAN_NOT_DEL_WHILE_RUN = errors.TN(SPIRIT_ERR_NS, 64, ...)

+ var ERR_INSTANCE_HASH_IS_EMPTY = errors.TN(SPIRIT_ERR_NS, 66, ...)

+ var ERR_INSTANCE_HOME_CREATE_FAILED = errors.TN(SPIRIT_ERR_NS, 60, "could not create instance home: {{.dir}}")

+ var ERR_INSTANCE_NAME_IS_EMPTY = errors.TN(SPIRIT_ERR_NS, 62, "instance name is empty")

+ var ERR_LOAD_INSTANCE_METADATA_FAILED = errors.TN(SPIRIT_ERR_NS, 63, ...)

+ var ERR_MARSHAL_CONFIG_FAILED = errors.TN(SPIRIT_ERR_NS, 74, "marshal config of {{.fileName}} failed, err: {{.err}}")

+ var ERR_MUST_CHECKOUT_BEFORE_REMOVE = errors.TN(SPIRIT_ERR_NS, 70, ...)

+ var ERR_OPTIONS_KEY_NOT_EXIST = errors.TN(SPIRIT_ERR_NS, 51, "options key of {{.key}} not exist")

+ var ERR_OPTIONS_VALUE_TYPE_ERROR = errors.TN(SPIRIT_ERR_NS, 52, ...)

+ var ERR_OPTIONS_VAL_TYPE_CONV_FAILED = errors.TN(SPIRIT_ERR_NS, 65, ...)

+ var ERR_REMOVE_BIN_ERROR = errors.TN(SPIRIT_ERR_NS, 71, "remove binary with hash {{.hash}} failed, err: {{.err}}")

+ var ERR_SAVE_INSTANCE_METADATA_FAILED = errors.TN(SPIRIT_ERR_NS, 61, ...)

+ var ERR_SPIRIT_COMMIT_MSG_NOT_INPUT = errors.TN(SPIRIT_ERR_NS, 1025, "commit message not input")

+ var ERR_SPIRIT_COMPONENT_CONF_DUP = errors.TN(SPIRIT_ERR_NS, 1006, "component of {{.name}}'s config duplicated")

+ var ERR_SPIRIT_COMPONENT_CONF_NOT_EXIST = errors.TN(SPIRIT_ERR_NS, 1005, ...)

+ var ERR_SPIRIT_COMPONENT_NOT_HOSTING = errors.TN(SPIRIT_ERR_NS, 1004, "component not hosting: {{.name}}")

+ var ERR_SPIRIT_COPY_INSTANCE_ERROR = errors.TN(SPIRIT_ERR_NS, 1023, "copy instance error, err: {{.err}}")

+ var ERR_SPIRIT_ENV_FORAMT_ERROR = errors.TN(SPIRIT_ERR_NS, 1002, "env format error: {{.env}}")

+ var ERR_SPIRIT_GET_INSTANCE_PID_FAILED = errors.TN(SPIRIT_ERR_NS, 1010, "get instance pid of {{.name}} failed, err: {{.err}}")

+ var ERR_SPIRIT_INSTANCE_ALREADY_CREATED = errors.TN(SPIRIT_ERR_NS, 1016, ...)

+ var ERR_SPIRIT_INSTANCE_HASH_NOT_INPUT = errors.TN(SPIRIT_ERR_NS, 1026, "spirit instance hash not input")

+ var ERR_SPIRIT_INSTANCE_NAME_NOT_INPUT = errors.TN(SPIRIT_ERR_NS, 1014, "please input instance name")

+ var ERR_SPIRIT_INSTANCE_NOT_EXIST = errors.TN(SPIRIT_ERR_NS, 1018, "spirit instance of {{.name}} not exist")

+ var ERR_SPIRIT_INSTANCE_NOT_RUNNING = errors.TN(SPIRIT_ERR_NS, 1022, "instance of {{.name}} may not running.")

+ var ERR_SPIRIT_KILL_INSTANCE_FIALED = errors.TN(SPIRIT_ERR_NS, 1020, ...)

+ var ERR_SPIRIT_LIST_INSTANCE_FAILED = errors.TN(SPIRIT_ERR_NS, 1011, "list instances failed, err: {{.err}}")

+ var ERR_SPIRIT_LOAD_COMPONENT_CONF_ERROR = errors.TN(SPIRIT_ERR_NS, 1008, ...)

+ var ERR_SPIRIT_LOCK_PID_FILE_FAILED = errors.TN(SPIRIT_ERR_NS, 1013, ...)

+ var ERR_SPIRIT_NO_COMPONENTS_TO_RUN = errors.TN(SPIRIT_ERR_NS, 1003, "no components to run")

+ var ERR_SPIRIT_NO_CONFIG_SPECIFIC = errors.TN(SPIRIT_ERR_NS, 1000, "no config file specific")

+ var ERR_SPIRIT_ONLY_ONE_INST_NAME = errors.TN(SPIRIT_ERR_NS, 1015, "only one instance name allowed")

+ var ERR_SPIRIT_PAUSE_INSTANCE_FIALED = errors.TN(SPIRIT_ERR_NS, 1021, ...)

+ var ERR_SPIRIT_READ_PID_FILE_ERROR = errors.TN(SPIRIT_ERR_NS, 1012, "read instance of {{.name}} pid file error: {{.err}}")

+ var ERR_SPIRIT_REMOVE_INSTANCE_FAILED = errors.TN(SPIRIT_ERR_NS, 1017, "remove spirit instance of [{{.name}}] error: {{.err}}")

+ var ERR_SPIRIT_SPIRIT_DID_NOT_BUILD = errors.TN(SPIRIT_ERR_NS, 1007, "spirit did not build")

+ var ERR_SPIRIT_START_CHILD_INSTANCE = errors.TN(SPIRIT_ERR_NS, 1024, "start child instance of {{.name}} failed, err: {{.err}}")

+ var ERR_SPIRIT_STOP_INSTANCE_FIALED = errors.TN(SPIRIT_ERR_NS, 1019, ...)

+ var ERR_SPIRIT_WRITE_PID_FILE_ERROR = errors.TN(SPIRIT_ERR_NS, 1009, "write pid file error: {{.err}}")

+ var ERR_WRITE_COMMIT_MESSAGE_ERROR = errors.TN(SPIRIT_ERR_NS, 69, "write commit message error: {{.err}}")

+ var ERR_WRITE_TMP_CONFIG_FILE_FAILED = errors.TN(SPIRIT_ERR_NS, 73, "write tmp config of {{.fileName}} failed, err: {{.err}}")

+ func RegisterHeartbeaters(beaters ...Heartbeater)

+ func RemoveHeartBeaters(names ...string)

+ func SetMessageHookFactory(factory MessageHookFactory)

+ func SetMessageReceiverFactory(factory MessageReceiverFactory)

+ func SetMessageSenderFactory(factory MessageSenderFactory)

+ type AssetProperty struct

+ FileName string

+ NeedBuild bool

+ type Author struct

+ Email string

+ Name string

type DefaultMessageHookFactory

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

type HeartbeatMessage

+ InstanceName string

type MessageHookFactory

+ func GetMessageHookFactory() MessageHookFactory

+ CreateHook func(hookType, name string, options Options) (hook MessageHook, err error)

type MessageReceiverFactory

+ func GetMessageReceiverFactory() MessageReceiverFactory

type MessageSenderFactory

+ func GetMessageSenderFactory() MessageSenderFactory

+ type Options map[string]interface

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

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

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

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

v0.1.0

Apr 20, 2015

Changes in this version

+ const BIG_DATA_MESSAGE_ID

+ const BIG_DATA_REDIS_EXPIRE_SECONDS

+ const ENV_EXT

+ const ENV_NAME

+ const ERROR_MSG_ADDR

+ const ERROR_MSG_ADDR_INT

+ const EXT_SPIRIT

+ const MAX_DATA_LENGTH

+ const SIG_PAUSE

+ const SIG_RESUME

+ const SIG_STOP

+ const SPIRIT

+ const SPIRIT_ERR_NS

+ var ERR_COMPONENT_HANDLER_NOT_EXIST = errors.TN(SPIRIT_ERR_NS, 6, ...)

+ var ERR_COMPONENT_HANDLER_PANIC = errors.TN(SPIRIT_ERR_NS, 29, ...)

+ var ERR_COMPONENT_HANDLER_RETURN_ERROR = errors.TN(SPIRIT_ERR_NS, 5, ...)

+ var ERR_HANDLER_NAME_IS_EMPTY = errors.TN(SPIRIT_ERR_NS, 24, "handler name is empty, component: {{.name}}")

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

+ var ERR_HEARTBEAT_CONFIG_FILE_IS_EMPTY = errors.TN(SPIRIT_ERR_NS, 30, "heartbeat config file is empty, heartbeat name: {{.name}}")

+ var ERR_HOOK_BAD_DRIVER = errors.TN(SPIRIT_ERR_NS, 36, "bad message hook driver of {{.type}}")

+ var ERR_HOOK_BIG_DATA_CREATE_REDIS = errors.TN(SPIRIT_ERR_NS, 43, "create redis error,{{.err}}")

+ var ERR_HOOK_BIG_DATA_OPEN_FILE = errors.TN(SPIRIT_ERR_NS, 41, "open file error,{{.err}}")

+ var ERR_HOOK_BIG_DATA_REDIS_GET = errors.TN(SPIRIT_ERR_NS, 44, "redis get data error,{{.err}}")

+ var ERR_HOOK_BIG_DATA_REDIS_SET = errors.TN(SPIRIT_ERR_NS, 45, "redis set data error,{{.err}}")

+ var ERR_HOOK_BIG_DATA_UNMARSHAL_CONF = errors.TN(SPIRIT_ERR_NS, 42, "envJson unmarshal config error,{{.err}}")

+ var ERR_HOOK_CREATE_FAILED = errors.TN(SPIRIT_ERR_NS, 34, "create receiver failed, driver type: {{.type}}")

+ var ERR_HOOK_DRIVER_NOT_EXIST = errors.TN(SPIRIT_ERR_NS, 35, "message hook driver not exist, type: {{.type}}")

+ var ERR_HOOK_INSTANCE_ALREADY_INITALED = errors.TN(SPIRIT_ERR_NS, 38, "hook instance already initaled, driver type: {{.type}}")

+ var ERR_HOOK_INSTANCE_NOT_INITALED = errors.TN(SPIRIT_ERR_NS, 39, "hook instance not initaled, driver type: {{.type}}")

+ var ERR_INPORT_NOT_BIND_HOOK = errors.TN(SPIRIT_ERR_NS, 40, "in port of {{.inPortName}} not bind hooks")

+ var ERR_JSON_MARSHAL = errors.TN(SPIRIT_ERR_NS, 47, "json marshal data error,{{.err}}")

+ var ERR_JSON_UNMARSHAL = errors.TN(SPIRIT_ERR_NS, 46, "json unmarshal data error,{{.err}}")

+ var ERR_MESSAGE_ADDRESS_IS_EMPTY = errors.TN(SPIRIT_ERR_NS, 3, "component message address is empty")

+ var ERR_MESSAGE_GRAPH_ADDRESS_NOT_FOUND = errors.TN(SPIRIT_ERR_NS, 1, ...)

+ var ERR_MESSAGE_GRAPH_IS_NIL = errors.TN(SPIRIT_ERR_NS, 2, "component graph is nil")

+ var ERR_MESSAGE_HOOK_ERROR = errors.TN(SPIRIT_ERR_NS, 37, ...)

+ var ERR_MESSAGE_SERIALIZE_FAILED = errors.TN(SPIRIT_ERR_NS, 4, "component message serialize failed, err: {{.err}}")

+ var ERR_PAYLOAD_GO_BAD = errors.TN(SPIRIT_ERR_NS, 27, "payload go bad, err: {{.err}}")

+ var ERR_PAYLOAD_SERIALIZE_FAILED = errors.TN(SPIRIT_ERR_NS, 28, "payload serialize failed, err: {{.err}}")

+ var ERR_PORT_NAME_IS_EMPTY = errors.TN(SPIRIT_ERR_NS, 23, "port name is empty, component: {{.name}}")

+ var ERR_READE_FILE_ERROR = errors.TN(SPIRIT_ERR_NS, 31, "read file error,file: {{.file}} err: {{.err}}")

+ var ERR_RECEIVER_BAD_DRIVER = errors.TN(SPIRIT_ERR_NS, 19, "bad message receiver driver of {{.type}}")

+ var ERR_RECEIVER_CREATE_FAILED = errors.TN(SPIRIT_ERR_NS, 20, ...)

+ var ERR_RECEIVER_CREDENTIAL_IS_NIL = errors.TN(SPIRIT_ERR_NS, 14, "credential is nil, type: {{.type}}")

+ var ERR_RECEIVER_DECODE_MESSAGE_FAILED = errors.TN(SPIRIT_ERR_NS, 22, ...)

+ var ERR_RECEIVER_DELETE_MSG_ERROR = errors.TN(SPIRIT_ERR_NS, 16, ...)

+ var ERR_RECEIVER_DRIVER_NOT_EXIST = errors.TN(SPIRIT_ERR_NS, 21, "message receiver driver not exist, type: {{.type}}")

+ var ERR_RECEIVER_MQS_CLIENT_IS_NIL = errors.TN(SPIRIT_ERR_NS, 15, ...)

+ var ERR_RECEIVER_RECV_ERROR = errors.TN(SPIRIT_ERR_NS, 18, ...)

+ var ERR_RECEIVER_UNMARSHAL_MSG_FAILED = errors.TN(SPIRIT_ERR_NS, 17, ...)

+ var ERR_SENDER_BAD_DRIVER = errors.TN(SPIRIT_ERR_NS, 13, "bad message sender driver of {{.type}}")

+ var ERR_SENDER_CREATE_FAILED = errors.TN(SPIRIT_ERR_NS, 11, "create sender failed, driver type: {{.type}}")

+ var ERR_SENDER_CREDENTIAL_IS_NIL = errors.TN(SPIRIT_ERR_NS, 8, "credential is nil, type: {{.type}}, url: {{.url}}")

+ var ERR_SENDER_DRIVER_NOT_EXIST = errors.TN(SPIRIT_ERR_NS, 12, "message sender driver not exist, type: {{.type}}")

+ var ERR_SENDER_MQS_CLIENT_IS_NIL = errors.TN(SPIRIT_ERR_NS, 9, "sender mqs client is nil, type: {{.type}}, url: {{.url}}")

+ var ERR_SENDER_SEND_FAILED = errors.TN(SPIRIT_ERR_NS, 10, ...)

+ var ERR_UNMARSHAL_DATA_ERROR = errors.TN(SPIRIT_ERR_NS, 32, "unmarshal data error, err: {{.err}}")

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

+ var MESSAGE_CHAN_SIZE = 1000

+ func GetComponentHome(spiritName string) string

+ func GetFdName(fd uintptr) (name string, err error)

+ func IsFileOrDir(filename string, decideDir bool) bool

+ func IsProcessAlive(pid int) bool

+ func KillProcess(pid int) (err error)

+ func MakeComponentHome(spiritName string) (dir string, err error)

+ func StartProcess(execFileName string, args []string, envs []string, std bool, extEnvs ...string) (pid int, err error)

+ type AliJiankong struct

+ func (p *AliJiankong) Heartbeat(heartbeatMessage HeartbeatMessage)

+ func (p *AliJiankong) Name() string

+ func (p *AliJiankong) Start(configFile string) (err error)

+ type BaseComponent struct

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

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

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

+ func (p *BaseComponent) Build() Component

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

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

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

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

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

+ func (p *BaseComponent) Name() string

+ func (p *BaseComponent) PauseOrResume()

+ func (p *BaseComponent) ReceiverLoop()

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

+ func (p *BaseComponent) Run()

+ func (p *BaseComponent) SetMessageHookFactory(factory MessageHookFactory) Component

+ func (p *BaseComponent) SetMessageSenderFactory(factory MessageSenderFactory) Component

+ func (p *BaseComponent) Status() ComponentStatus

+ func (p *BaseComponent) Stop()

+ type ClassicSpirit struct

+ func (p *ClassicSpirit) Build() Spirit

+ func (p *ClassicSpirit) GetComponent(name string) Component

+ func (p *ClassicSpirit) GetMessageHookFactory() MessageHookFactory

+ func (p *ClassicSpirit) GetMessageReceiverFactory() MessageReceiverFactory

+ func (p *ClassicSpirit) GetMessageSenderFactory() MessageSenderFactory

+ func (p *ClassicSpirit) Hosting(components ...Component) Spirit

+ func (p *ClassicSpirit) RegisterHeartbeaters(beaters ...Heartbeater) Spirit

+ func (p *ClassicSpirit) RemoveHeartBeaters(names ...string) Spirit

+ func (p *ClassicSpirit) Run(initialFuncs ...InitalFunc)

+ func (p *ClassicSpirit) SetMessageHookFactory(factory MessageHookFactory)

+ func (p *ClassicSpirit) SetMessageReceiverFactory(factory MessageReceiverFactory)

+ func (p *ClassicSpirit) SetMessageSenderFactory(factory MessageSenderFactory)

+ type Component interface

+ AddInPortHooks func(inportName string, hooks ...string) Component

+ BindHandler func(inPortName string, handlerName string) Component

+ BindReceiver func(inPortName string, receivers ...MessageReceiver) Component

+ Build func() Component

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

+ ClearInPortHooks func(inportName string) (err error)

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

+ GetReceivers func(inPortName string) []MessageReceiver

+ ListHandlers func() (handlers map[string]ComponentHandler, err error)

+ Name func() string

+ PauseOrResume func()

+ RegisterHandler func(name string, handler ComponentHandler) Component

+ Run func()

+ SetMessageHookFactory func(factory MessageHookFactory) Component

+ SetMessageSenderFactory func(factory MessageSenderFactory) Component

+ Status func() ComponentStatus

+ Stop func()

+ func NewBaseComponent(componentName string) Component

+ type ComponentCommands map[string][]interface

+ type ComponentContext map[string]interface

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

+ type ComponentMessage struct

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

+ func (p *ComponentMessage) Id() string

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

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

+ type ComponentStatus int

+ const STATUS_PAUSED

+ const STATUS_READY

+ const STATUS_RUNNING

+ const STATUS_STOPED

+ const STATUS_STOPPING

+ type DefaultMessageHookFactory struct

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

+ func (p *DefaultMessageHookFactory) InitalHook(hookType, configFile string) (hook MessageHook, err error)

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

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

+ type DefaultMessageReceiverFactory struct

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

+ func (p *DefaultMessageReceiverFactory) NewReceiver(receiverType, url string, configFile string) (receiver MessageReceiver, err error)

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

+ type DefaultMessageSenderFactory struct

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

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

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

+ type Error struct

+ AddressId int32

+ Code uint64

+ Id string

+ Message string

+ Namespace string

+ type HeartbeatMessage struct

+ Component string

+ CurrentTime time.Time

+ HeartbeatCount int64

+ HostName string

+ PID int

+ StartTime time.Time

+ type Heartbeater interface

+ Heartbeat func(heartbeatMessage HeartbeatMessage)

+ Name func() string

+ Start func(configFile string) error

+ type HookEvent int32

+ const HookEventAfterCallHandler

+ const HookEventBeforeCallHandler

+ type InitalFunc func(configFile string) (err error)

+ type LockFile struct

+ func CreateLockFile(name string, perm os.FileMode) (lockfile *LockFile, err error)

+ func NewLockFile(file *os.File) *LockFile

+ func OpenLockFile(name string, perm os.FileMode) (lockfile *LockFile, err error)

+ func (p *LockFile) Lock() error

+ func (p *LockFile) ReadContent() (content LockFileContent, err error)

+ func (p *LockFile) Remove() (err error)

+ func (p *LockFile) Unlock() error

+ func (p *LockFile) WriteContent(context map[string]interface{}) (err error)

+ type LockFileContent struct

+ Context map[string]interface{}

+ PID int

+ func Read(name string) (content LockFileContent, err error)

+ type MessageAddress struct

+ Type string

+ Url string

+ type MessageGraph map[string]MessageAddress

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

+ func (p MessageGraph) ClearErrorAddress()

+ func (p MessageGraph) SetErrorAddress(address MessageAddress)

+ type MessageHook interface

+ HookAfter func(previousMetadatas []MessageHookMetadata, ...) (ignored bool, newMetaData MessageHookMetadata, err error)

+ HookBefore func(currentMetadata MessageHookMetadata, previousMetadatas []MessageHookMetadata, ...) (ignored bool, newMetaData MessageHookMetadata, err error)

+ Init func(configFile string) error

+ Name func() string

+ type MessageHookBigDataRedis struct

+ func (p *MessageHookBigDataRedis) HookAfter(previousMetadatas []MessageHookMetadata, ...) (ignored bool, newMetaData MessageHookMetadata, err error)

+ func (p *MessageHookBigDataRedis) HookBefore(currentMetadata MessageHookMetadata, previousMetadatas []MessageHookMetadata, ...) (ignored bool, newMetaData MessageHookMetadata, err error)

+ func (p *MessageHookBigDataRedis) Init(configFile string) (err error)

+ func (p *MessageHookBigDataRedis) Name() string

+ type MessageHookFactory interface

+ Get func(hookType string) (hook MessageHook, err error)

+ InitalHook func(hookType, configFile string) (hook MessageHook, err error)

+ IsExist func(hookType string) bool

+ RegisterMessageHooks func(hooks ...MessageHook)

+ func NewDefaultMessageHookFactory() MessageHookFactory

+ type MessageHookMetadata struct

+ Context map[string]interface{}

+ HookName string

+ type MessageReceiver interface

+ Address func() MessageAddress

+ Init func(url, configFile string) error

+ Receive func(portChan *PortChan)

+ Type func() string

+ func NewMessageReceiverMQS(url string) MessageReceiver

+ type MessageReceiverFactory interface

+ IsExist func(receiverType string) bool

+ NewReceiver func(receiverType, url string, configFile string) (receiver MessageReceiver, err error)

+ RegisterMessageReceivers func(receivers ...MessageReceiver)

+ func NewDefaultMessageReceiverFactory() MessageReceiverFactory

+ type MessageReceiverMQS struct

+ func (p *MessageReceiverMQS) Address() MessageAddress

+ func (p *MessageReceiverMQS) Init(url, configFile string) (err error)

+ func (p *MessageReceiverMQS) Receive(portChan *PortChan)

+ func (p *MessageReceiverMQS) Type() string

+ type MessageSender interface

+ Init func() error

+ Send func(url string, message ComponentMessage) (err error)

+ Type func() string

+ func NewMessageSenderMQS() MessageSender

+ type MessageSenderFactory interface

+ IsExist func(senderType string) bool

+ NewSender func(senderType string) (sender MessageSender, err error)

+ RegisterMessageSenders func(senders ...MessageSender)

+ func NewDefaultMessageSenderFactory() MessageSenderFactory

+ type MessageSenderMQS struct

+ func (p *MessageSenderMQS) Init() (err error)

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

+ func (p *MessageSenderMQS) Type() string

+ type Payload struct

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

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

+ func (p *Payload) Error() Error

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (p *Payload) GoBad(e error)

+ func (p *Payload) Id() string

+ func (p *Payload) IsCorrect() bool

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

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

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

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

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

+ type PortChan struct

+ Error chan error

+ Message chan ComponentMessage

+ Signal chan int

+ Stoped chan bool

+ type Spirit interface

+ Build func() Spirit

+ GetComponent func(name string) Component

+ GetMessageHookFactory func() MessageHookFactory

+ GetMessageReceiverFactory func() MessageReceiverFactory

+ GetMessageSenderFactory func() MessageSenderFactory

+ Hosting func(components ...Component) Spirit

+ RegisterHeartbeaters func(beaters ...Heartbeater) Spirit

+ RemoveHeartBeaters func(names ...string) Spirit

+ Run func(initalFuncs ...InitalFunc)

+ SetMessageHookFactory func(factory MessageHookFactory)

+ SetMessageReceiverFactory func(factory MessageReceiverFactory)

+ SetMessageSenderFactory func(factory MessageSenderFactory)

+ func NewClassicSpirit(name, description, version string) Spirit

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