cap

type Bootstrapper struct {
	Servers              []IProcessServer
	CapOptions           *CapOptions
	Register             *CallbackRegister
	ConnectionFactory    *StorageConnectionFactory
	QueueExecutorFactory IQueueExecutorFactory
	WaitGroup            *sync.WaitGroup
	// contains filtered or unexported fields
}

type Callback struct {
}

type CallbackInfo struct {
	CallbackType reflect.Type
}

type CallbackInterface interface {
	Handle(msg interface{}) error
}

type CallbackRegister struct {
	// [groupName][routeName] = CallbackInfo
	Routers map[string]map[string]*CallbackInfo
}

type CapError struct {
	When time.Time
	What string
}

type CapOptions struct {
	ConnectionString string
	PoolingDelay     time.Duration
}

type CapPublishedMessage struct {
	Id             int
	Name           string
	Content        string
	Added          int
	ExpiresAt      int
	Retries        int
	StatusName     string
	LastWarnedTime int
	MessageId      int64
	TransactionId  int64
}

type CapReceivedMessage struct {
	Id             int
	Name           string
	Group          string
	Content        string
	Added          int64
	ExpiresAt      int
	Retries        int
	StatusName     string
	LastWarnedTime int
	MessageId      int64
	TransactionId  int64
}

type DefaultDispatcher struct {
	StorageConnectionFactory *StorageConnectionFactory
	CapOptions               *CapOptions
	QueueExecutorFactory     IQueueExecutorFactory
	// contains filtered or unexported fields
}

type DefaultLogger struct {
	TypeName string
	// contains filtered or unexported fields
}

type EnqueuedState struct {
	IState
}

type ErrorHanlder func(str string)

type FailedJobProcessor struct {
	Options                  *CapOptions
	StateChanger             IStateChanger
	StorageConnectionFactory *StorageConnectionFactory
	// contains filtered or unexported fields
}

type FailedState struct {
	IState
}

type FeiniuBusMessage struct {
	MetaData FeiniuBusMessageMetaData `json:"meta"`
	Content  string                   `json:"content"`
}

type FeiniuBusMessageMetaData struct {
	TransactionID int64 `json:"transaction_id,string"`
	MessageID     int64 `json:"message_id,string"`
}

type IConsumerClient interface {
	Subscribe(topics []string)
	Listening(timeoutSecs int, ch chan bool)
	Commit(context MessageContext)
	Close()
	SetOnReceive(onReceive ReceiveHanlder)
	SetOnError(onError ErrorHanlder)
}

type IConsumerClientFactory interface {
	Create(group string) IConsumerClient
}

type IConsumerHandler interface {
	IProcessServer
}

type IDispatcher interface {
	IProcessor
}

type IFetchedMessage interface {
	GetMessageId() (messageId int)

	GetMessageType() (messageType int)

	RemoveFromQueue() error
	Requeue() error

	Dispose() error
}

type ILockedMessage interface {
	Prepare(statement string) (stmt interface{}, err error)
	Commit() error
	Rollback() error
	Dispose()
	GetMessage() interface{}
	GetMessageType() int32
	ChangeState(state IState) error
}

type ILockedMessages interface {
	Prepare(statement string) (stmt interface{}, err error)
	Commit() error
	Rollback() error
	Dispose()
	ChangeStates(state IState) error
	GetMessages() []ILockedMessage
	GetMessageType() int32
	AppendMessage(i interface{})
}

type ILogger interface {
	Log(level LogLevel, message string)
	LogData(level LogLevel, message string, data interface{})
}

type IProcessServer interface {
	Start()
	WaitForClose(wg *sync.WaitGroup)
}

type IProcessor interface {
	Process(context *ProcessingContext) (*ProcessResult, error)
}

type IPublishDelegate interface {
	Publish(keyName, content string) error
}

type IPublisher interface {
	Publish(descriptors []*MessageDescriptor, connection interface{}, transaction interface{}) error

	PublishOne(name string, content interface{}, connection interface{}, transaction interface{}) error
}

type IQueueExecutor interface {
	Execute(connection IStorageConnection, feched IFetchedMessage) error
}

type IQueueExecutorFactory interface {
	SetPublishQueueExecutorCreateDelegate(delegate PublishQueueExecutorCreateDelegate)
	GetPublishQueueExecutorCreateDelegate() PublishQueueExecutorCreateDelegate
	GetInstance(messageType string) IQueueExecutor
}

type IReceivedMessageHandler interface {
	Handle(message interface{})
}

type IState interface {
	GetExpiresAfter() int32
	GetName() string
	ApplyReceivedMessage(message *CapReceivedMessage, transaction IStorageTransaction) error
	ApplyPublishedMessage(message *CapPublishedMessage, transaction IStorageTransaction) error
}

type IStateChanger interface {
	ChangeReceivedMessageState(message *CapReceivedMessage, state IState, transaction IStorageTransaction) error
	ChangePublishedMessage(message *CapPublishedMessage, state IState, transaction IStorageTransaction) error
}

type IStorageConnection interface {
	CreateTransaction() (IStorageTransaction, error)

	FetchNextMessage() (IFetchedMessage, error)

	GetFailedPublishedMessages() ([]*CapPublishedMessage, error)

	GetFailedReceivedMessages() ([]*CapReceivedMessage, error)

	GetNextPublishedMessageToBeEnqueued() (*CapPublishedMessage, error)

	GetNextReceviedMessageToBeEnqueued() (*CapReceivedMessage, error)

	GetPublishedMessage(id int) (*CapPublishedMessage, error)

	GetReceivedMessage(id int) (*CapReceivedMessage, error)

	StoreReceivedMessage(message *CapReceivedMessage) error

	GetNextLockedMessageToBeEnqueued(messageType int32) (ILockedMessage, error)

	GetFailedLockedMessages(messageType int32) (ILockedMessages, error)
}

type IStorageTransaction interface {
	Commit() error

	EnqueuePublishedMessage(message *CapPublishedMessage) error

	EnqueueReceivedMessage(message *CapReceivedMessage) error

	UpdatePublishedMessage(message *CapPublishedMessage) error

	UpdateReceivedMessage(message *CapReceivedMessage) error

	Dispose()
}

type InfiniteRetryProcessor struct {
	InnerProcessor IProcessor
	Status         string
	// contains filtered or unexported fields
}

type LogDelegate struct {
	// Log ...
	Log func(level LogLevel, message string, data interface{})
}

type LogLevel int

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

type Looper struct {
}

type MessageContext struct {
	Group   string
	Name    string
	Content string
	Tag     uint64
}

type MessageDescriptor struct {
	Name    string
	Content interface{}
}

type ProcessResult struct {
	Status       string
	PollingDelay time.Duration
}

type ProcessingContext struct {
	IsStopping bool
}

type ProcessingState struct {
	IState
}

type ProcessorContainer struct {
	Processors []IProcessor
}

type ProcessorServer struct {
	Container  *ProcessorContainer
	Context    *ProcessingContext
	Processors []*InfiniteRetryProcessor
}

type PublishQueueExecutorCreateDelegate func() IQueueExecutor

type PublishQueuer struct {
	StateChanger             IStateChanger
	Options                  *CapOptions
	StorageConnectionFactory *StorageConnectionFactory
	// contains filtered or unexported fields
}

type PublisherFactory struct {
	CreatePublisher func(options *CapOptions) (IPublisher, error)
}

type QueueExecutorFactory struct {
	IQueueExecutorFactory
	PublishQueueExecutorCreateDelegate PublishQueueExecutorCreateDelegate
	Register                           *CallbackRegister
}

type QueueExecutorPublish struct {
	IQueueExecutor
	StateChanger    IStateChanger
	PublishDelegate IPublishDelegate
	// contains filtered or unexported fields
}

type QueueExecutorSubscribe struct {
	IQueueExecutor
	Register *CallbackRegister
	// contains filtered or unexported fields
}

type ReceiveHanlder func(ctx MessageContext)

type RetryBehavior struct {
	RetryInThunk RetryInThunk
	Retry        bool
	RetryCount   int32
}

type RetryInThunk func(retries int32) int32

type ScheduledState struct {
	IState
}

type StateChanger struct {
}

type StorageConnectionFactory struct {
	CreateStorageConnection func(options *CapOptions) (IStorageConnection, error)
}

type SubscribeQueuer struct {
	Options                  *CapOptions
	StorageConnectionFactory *StorageConnectionFactory
	// contains filtered or unexported fields
}

type SucceededState struct {
	IState
}