micro

type Channel[T ShardCommand] chan Command

type Client struct {
	*nats.Conn
	// contains filtered or unexported fields
}

type ClientOption func(*Client)

type Command struct {
	Name    string          // The command name
	Address *ServiceAddress // Service address this command is sent to
	Persona string          // Sender's persona
	Payload any             // The command payload itself
}

type Handler func(ctx context.Context, req *Request) *Response

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

type JetStreamSnapshotStorageOptions struct {
	ObjectName string `env:"SHARD_SNAPSHOT_JETSTREAM_OBJECT_NAME" envDefault:"snapshot"`
	// Maximum bytes for snapshot storage (ObjectStore). // Required by some NATS providers like Synadia Cloud.
	SnapshotStorageMaxBytes uint64 `env:"SHARD_SNAPSHOT_STORAGE_MAX_BYTES" envDefault:"0"`
	// contains filtered or unexported fields
}

type NATSConfig struct {
	Name            string `env:"NATS_NAME" envDefault:"isc"`
	URL             string `env:"NATS_URL" envDefault:"nats://nats:4222"`
	CredentialsFile string `env:"NATS_CREDENTIALS_FILE"`
}

type NopSnapshotStorage struct{}

type Realm = microv1.ServiceAddress_Realm

type Request struct {
	// Raw is the original NATS message.
	Raw *nats.Msg

	// RequestID is extracted from the request if available.
	RequestID string

	// ServiceAddress contains the service address information.
	ServiceAddress *microv1.ServiceAddress

	// Payload contains the decoded request payload, if any.
	Payload *anypb.Any
}

type Response struct {
	// RequestID is copied from the request.
	RequestID string

	// ServiceAddress contains the service address information.
	ServiceAddress *microv1.ServiceAddress

	// Status contains the response status information.
	Status *spb.Status

	// Payload contains the response payload, if any.
	Payload *anypb.Any
}

type Service struct {
	Address *ServiceAddress // This service's address
	Version string          // Version represents the service version.
	// contains filtered or unexported fields
}

type ServiceAddress = microv1.ServiceAddress

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

type ServiceID = string

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

type ShardCommand interface {
	Name() string
}

type ShardEngine interface {
	// Init initializes the shard's initial state.
	Init() error

	// Tick processes the given input and advances the shard state.
	Tick(Tick) error

	// Replay processes the given input during state reconstruction.
	// This should produce the same result as Tick for deterministic replay.
	Replay(Tick) error

	// StateHash returns a hash of the current shard state for consistency verification.
	StateHash() ([]byte, error)

	// Snapshot captures the current shard state and returns it as serialized bytes.
	Snapshot() ([]byte, error)

	// Restore restores the shard state from the given serialized bytes.
	Restore(data []byte) error

	// Reset resets the engine to its clean initial state.
	Reset()
}

type ShardMode uint8

type ShardOptions struct {
	Client                 *Client                // NATS client
	Address                *ServiceAddress        // Shard's service address
	Mode                   ShardMode              // Operation mode (Leader or Follower)
	EpochFrequency         uint32                 // Number of ticks per epoch
	TickRate               float64                // Number of ticks per second
	Telemetry              *telemetry.Telemetry   // Telemetry for logging and tracing
	SnapshotStorageType    SnapshotStorageType    // Snapshot storage type
	SnapshotStorageOptions SnapshotStorageOptions // Optional snapshot storage options
	SnapshotFrequency      uint32                 // Number of epochs per snapshot
	DisablePersona         bool                   // Disable persona verification for development/testing
	EpochStreamMaxBytes    uint32                 // Maximum bytes for epoch stream (required by some NATS providers)
}

type Snapshot = microv1.Snapshot

type SnapshotStorage interface {
	// Store saves the snapshot, atomically replacing any existing snapshot.
	// The previous snapshot should be preserved as backup if possible.
	Store(snapshot *Snapshot) error

	// Load retrieves the current snapshot.
	// Returns an error if no snapshot exists.
	Load() (*Snapshot, error)

	// Exists checks if a current snapshot is available.
	Exists() bool
}

type SnapshotStorageOptions interface {
	// contains filtered or unexported methods
}

type SnapshotStorageType uint8

type Tick struct {
	Header TickHeader // Metadata about when and which tick this represents
	Data   TickData   // The actual commands processed during this tick
}

type TickData struct {
	Commands []Command // List of commands executed in this tick
}

type TickHeader struct {
	TickHeight uint64    // Tick height
	Timestamp  time.Time // When this tick was created
}