chassis

type BlueprintCluster struct {
	sync.Mutex
	Nodes []*sdv1.Node
}

type Broker interface {
	Open(ctx context.Context, config Config) error
	Publish(ctx context.Context, options PublishOptions) error
	Subscribe(ctx context.Context, options SubscribeOptions) error
	Unsubscribe(ctx context.Context, options UnsubscribeOptions) error
	Close(force bool) error
}

type CloseChan = chan os.Signal

type Config interface {
	Name() string
	Domain() string
	NodeID() string
	Title() string
	Env() string
	LogLevel() LogLevel
	Reader
	Writer
	Entrypoint() string
}

type ConsensusKind int

type ConsensusRegistrar interface {
	RegisterConsensus(interface{}) error
	// LeadershipChange is a callback for the consensus system to notify when a leadership change is made. The
	// leader parameter is true when the node becomes the leader, and false when it becomes a follower. The address
	// parameter is the URL of this node and should be persisted to raft for other nodes to forward write requests to.
	LeadershipChange(log Logger, leader bool, address string)
	raft.FSM
}

type Consumer interface {
	Consume(ctx context.Context, event *events.CloudEvent) error
}

type Default interface {
	RPCRegistrar
	ConsensusRegistrar
}

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

type Fields map[string]any

type LogLevel uint32

type Logger interface {
	// Start configures the logger for service startup
	Start(config Config)
	// SetLevel sets the logging level for the logger
	SetLevel(level LogLevel)
	// GetLevel gets the current logging level for the logger
	GetLevel() LogLevel
	// Wrap wraps an error with the additional context of current
	// logger fields and call stack information.
	Wrap(error) error
	// WithError - Add an error as single field (using the key defined in ErrorKey) to the logger.
	WithError(err error) Logger
	// WithContext - Add a context to the logger.
	WithContext(ctx context.Context) Logger
	// WithField - Add a single field to the logger.
	WithField(key string, value any) Logger
	// WithFields - Add a map of fields to the logger.
	WithFields(fields Fields) Logger
	// WithCallDepth - Configures the number of frames to skip on the stack when determining the function name of the caller.
	// Useful when wrapping the Logger interface for compatability with other logging interfaces.
	WithCallDepth(depth int) Logger
	// Trace - Definition:
	// "Seriously, WTF is going on here?!?!
	// I need to log every single statement I execute to find this @#$@ing memory corruption bug before I go insane"
	Trace(msg string)
	// Debug - Definition:
	// Off by default, able to be turned on for debugging specific unexpected problems.
	// This is where you might log detailed information about key method parameters or
	// other information that is useful for finding likely problems in specific 'problematic' areas of the code.
	Debug(msg string)
	Debugf(format string, args ...any)
	// Info - Definition:
	// Normal logging that's part of the normal operation of the app;
	// diagnostic stuff so you can go back and say 'how often did this broad-level operation happen?',
	// or 'how did the user's data get into this state?'
	Info(msg string)
	Infof(format string, args ...any)
	// Warn - Definition:
	// something that's concerning but not causing the operation to abort;
	// # of connections in the DB pool getting low, an unusual-but-expected timeout in an operation, etc.
	// Think of 'WARN' as something that's useful in aggregate; e.g. grep, group,
	// and count them to get a picture of what's affecting the system health
	Warn(msg string)
	Warnf(format string, args ...any)
	// Error - Definition:
	// something that the app's doing that it shouldn't.
	// This isn't a user error ('invalid search query');
	// it's an assertion failure, network problem, etc etc.,
	// probably one that is going to abort the current operation
	Error(msg string)
	Errorf(format string, args ...any)
	// WrappedError - Definition:
	// this is a convenience method that calls Error() but makes sure to wrap the error a final time
	// so that all current call context is included in the error. This has the same output as:
	//   logger.WithFields(logger.WrapError(err).Fields()).WithError(logger.WrapError(err)).Error("failed to process request")
	// but instead has a much simpler oneliner of:
	//   logger.WrappedError(err, "failed to process request")
	WrappedError(error, string)
	// Fatal - Definition:
	// the app (or at the very least a thread) is about to die horribly.
	// This is where the info explaining why that's happening goes.
	Fatal(msg string)
	// Panic - Definition:
	// Be careful about calling this vs Fatal:
	// - For Fatal level, the log message goes to the configured log output, while panic is only going to write to stderr.
	// - Panic will print a stack trace, which may not be relevant to the error at all.
	// - Defers will be executed when a program panics, but calling os.Exit exits immediately, and deferred functions can't be run.
	// In general, only use panic for programming errors, where the stack trace is important to the context of the error.
	// If the message isn't targeted at the programmer, you're simply hiding the message in superfluous data.
	Panic(msg string)
}

type PublishOptions struct {
	Event *events.CloudEvent
	// Tags are an optional list of strings that can be used to contextualize the event. For example, a tag could be used in
	// a blue/green deployment scenario to indicate which version of the application published the event. Keep in mind that tags
	// are only *contextual* data and though they do affect the routing of the event, they do not affect the content of the event.
	// For a consumer to receive an event, it must have a matching event type and all tags that were used when the event was published.
	// Tags will be sorted alphabetically before being used to route the event so that the order of the tags does not matter.
	Tags []string
}

type RPCHandlerKind int

type RPCRegistrar interface {
	RegisterRPC(server Rpcer)
}

type RaftController interface {
	Join(ctx context.Context, nodeID, raftAddress string) error
	Stats(ctx context.Context) map[string]string

	GetClusterDetails() raft.Configuration
}

type RaftRPCHandler interface {
	RPCRegistrar
	rfConnect.RaftServiceHandler
}

type Reader interface {
	Get(key string) interface{}
	GetString(key string) string
	GetBool(key string) bool
	GetInt(key string) int
	GetInt32(key string) int32
	GetInt64(key string) int64
	GetUint(key string) uint
	GetUint16(key string) uint16
	GetUint32(key string) uint32
	GetUint64(key string) uint64
	GetFloat64(key string) float64
	GetTime(key string) time.Time
	GetDuration(key string) time.Duration
	GetIntSlice(key string) []int
	GetStringSlice(key string) []string
	GetStringMap(key string) map[string]interface{}
	GetStringMapString(key string) map[string]string
	GetStringMapStringSlice(key string) map[string][]string
	GetSizeInBytes(key string) uint
	Unmarshal(rawVal interface{}, opts ...viper.DecoderConfigOption) error
	UnmarshalKey(key string, rawVal interface{}, opts ...viper.DecoderConfigOption) error
}

type RegistrationOptions struct {
	Namespace string
	Metadata  map[string]string
}

type Repository interface {
	Open(ctx context.Context, config Config) (err error)
	Ping(ctx context.Context) (err error)
	Close(ctx context.Context) (err error)
}

type Rpcer interface {
	AddHandler(pattern string, handler http.Handler, enableReflection bool)
	GetGrpcServer() *grpc.Server
}

type Runtime struct {
	RaftController RaftController
	// contains filtered or unexported fields
}

type SecretStore interface {
	// Open will initialize the client with the given configuration
	Open(ctx context.Context, config Config) (err error)
	// Get retrieves a secret from the vault for the given key
	Get(ctx context.Context, key string) (value string, err error)
}

type SubscribeOptions struct {
	Event *events.CloudEvent
	// Tags are an optional list of strings that can be used to filter the events that are received. For example, a tag could be used
	// in a blue/green deployment scenario to filter out events that were published by the other version of the application. If no tags
	// are provided, all events that match the provided Event will be received.
	Tags     []string
	Consumer Consumer
	// Group is the name of the group the consumer belongs to. If not empty, messages delivered to the group
	// will be load-balanced across all consumers within the group. If empty, the consumer will receive all
	// messages that match the provided Event and Tags.
	//
	// WARNING: Make sure that this value is globally unique across all other groups that are consuming the same event. Otherwise
	// messages could be delivered to consumers unintentionally.
	Group string
	// IgnoreType states whether the subscribing consumer should ignore the event type when receiving messages. If true, the consumer
	// will receive all events that match Event.Source and any provided Tags. If false, the consumer will only receive events that match
	// Event.Source, Event.Type, and any provided Tags.
	IgnoreType bool
}

type UnsubscribeOptions struct {
	Event      *events.CloudEvent
	Tags       []string
	IgnoreType bool
}

type Writer interface {
	Set(key string, value any)
	SetDefault(key string, value any)
	SetAndWrite(key string, value any) error
	WriteConfig() error
}