agentiface

type Agent interface {
	Sync
	io.Closer

	Identity

	Logger
	Messaging
	Cli
	Config
	SchemaRegistry
	TypeRegistry

	Manifest() Manifest
}

type Cli interface {
	ParseCommandLine() error
	RegisterCommand(cmd *cobra.Command)
	RootCommand() *cobra.Command
}

type CommandCallback func(ctx CommandCtx) error

type CommandCtx interface {
	Ctx

	// SendEvent sends an event as a consequence of this message (correlationId is set)
	SendEvent(command interface{}) error

	// SendCommand sends a new command as a consequence of this command (correlationId is set)
	SendCommand(to string, command interface{}) error
}

type Config interface {
	LoadConfig() error
	LoadConfigFrom(path string) error
	CreateDefaultConfig() error
	CreateDefaultConfigOverwrite() error
	PrintConfig(w io.Writer) error
	SetDefaultConfigOption(key string, value interface{})
	BindConfigPFlag(key string, flag *pflag.Flag) error
	GetConfigString(key string) string
}

type Ctx interface {
	// Messaging returns the instance of Messaging.
	Messaging() Messaging

	// Command returns the concrete instance of the deserialized message.
	Message() interface{}

	// The (Avro) schema of the message serialized.
	Schema() Schema

	// Properties returns the properties attached to the message.
	Properties() map[string]string
}

type EventCallback func(ctx EventCtx) error

type EventCtx interface {
	Ctx

	// SendCommand sends a command as a consequence of this event (correlationId is set)
	SendCommand(to string, command interface{}) error
}

type EventFilter map[string]interface{}

type Identity interface {
	ID() string
}

type Logger interface {
	// Emergency logs a message indicating the system is unusable.
	Emergency(format string, a ...interface{})
	// Alert logs a message indicating action must be taken immediately.
	Alert(format string, a ...interface{})
	// Critical logs a message indicating critical conditions.
	Critical(format string, a ...interface{})
	// Error logs a message indicating an error condition.
	// This method takes one or multiple parameters. If a single parameter
	// is provided, it will be treated as the log message. If multiple parameters
	// are provided, they will be passed to fmt.Sprintf() to generate the log message.
	Error(format string, a ...interface{})
	// Warning logs a message indicating a warning condition.
	Warning(format string, a ...interface{})
	// Info logs a message for informational purpose.
	Info(format string, a ...interface{})
	// Debug logs a message for debugging purpose.
	Debug(format string, a ...interface{})
}

type Manifest interface {
	Name() string
	Description() string
	Version() string
	Spec() map[string]interface{}
}

type MessageName string

type Messaging interface {
	Connect() error
	Disconnect() error
	State() State

	RegisterStateCallback(stateCallback StateCallback) string

	RegisterCommandCallback(commandName MessageName, commandCallback CommandCallback) (string, error)

	RegisterEventCallback(filter EventFilter, eventCallback EventCallback) (string, error)

	SendCommand(to string, command interface{}) error
}

type Schema interface {
	// Id returns the Unique identifier used to reference the schema.
	ID() string
	// Title returns the schema title.
	Title() string
	// MimeType returns the mimetype of the schema.
	MimeType() string
	// Raw returns the schema in raw format.
	Raw() string

	// Decode unserializes a message with its schema.
	Decode(o []byte, t Type) (interface{}, error)
	// Code serializes a message with its schema.
	Code(o interface{}) ([]byte, error)
}

type SchemaRegistry interface {
	// SchemaRegister registers a new Schema in the registry.
	SchemaRegister(schema Schema) (string, error)
	// SchemaGetByID retrieve the Schema in the registry given its id.
	SchemaGetByID(id string) (Schema, error)
	// SchemaListNames list all the Schemas contained in the registry.
	SchemaListIds() []string
	// SchemaUnregister removes the schema from the registry.
	SchemaUnregister(id string) error
	// SchemaExist check if the given schema exists in the registry.
	SchemaExist(id string) bool
}

type State int

type StateCallback func(state State) error

type Sync interface {
	// Go
	Go(f func(quit <-chan struct{}) error)
	// Quit
	Quit()
	// Wait
	Wait() error
}

type Type interface {
	// Name returns the name of the type.
	Name() string
	// Type returns the a reflection type (reflection).
	Type() reflect.Type
}

type TypeRegistry interface {
	// TypeRegister registers a new Type in the registry.
	TypeRegister(t Type) (string, error)
	// TypeGetByName retrieve the Type in the registry given its key.
	TypeGetByName(key string) (Type, error)
	// TypeGetByType retrieve the type in the registry given its type.
	TypeGetByType(t reflect.Type) (Type, error)
	// TypeListNames list all the item names (Types) contained in the registry.
	TypeListNames() []string
	// TypeUnregister removes the item from the registry.
	TypeUnregister(key string) error
	// TypeExist check if the given key exists in the registry.
	TypeExist(key string) bool
}