types

type AddrPort struct {
	netip.AddrPort
}

type AddrPorts []AddrPort

type CertificateName string

type Client interface {
	// Generic functions for the client interface.
	// They allow adding custom client functions.
	URL() *url.URL
	HTTP() *http.Client
	Query(ctx context.Context, method string, prefix EndpointPrefix, path *url.URL, in any, out any) error
	QueryRaw(ctx context.Context, method string, prefix EndpointPrefix, path *url.URL, in any) (*http.Response, error)
	Websocket(ctx context.Context, prefix EndpointPrefix, path *url.URL) (*websocket.Conn, error)

	// Microcluster specific client functions.
	SetClusterNotification()
	UseTarget(name string) Client
}

type Clients []Client

type ClusterCertificatePut struct {
	PublicKey  string `json:"public_key"  yaml:"public_key"`
	PrivateKey string `json:"private_key" yaml:"private_key"`
	CA         string `json:"ca"          yaml:"ca"`
}

type ClusterMember struct {
	ClusterMemberLocal
	Role                  string       `json:"role" yaml:"role"`
	SchemaInternalVersion uint64       `json:"schema_internal_version" yaml:"schema_internal_version"`
	SchemaExternalVersion uint64       `json:"schema_external_version" yaml:"schema_external_version"`
	LastHeartbeat         time.Time    `json:"last_heartbeat" yaml:"last_heartbeat"`
	Status                MemberStatus `json:"status" yaml:"status"`
	Extensions            Extensions   `json:"extensions" yaml:"extensions"`
	Secret                string       `json:"secret" yaml:"secret"`
}

type ClusterMemberLocal struct {
	Name        string          `json:"name" yaml:"name"`
	Address     AddrPort        `json:"address" yaml:"address"`
	Certificate X509Certificate `json:"certificate" yaml:"certificate"`
}

type Connector interface {
	// Cluster returns a client to every cluster member according to dqlite.
	Cluster(isNotification bool) (Clients, error)

	// Leader returns a client to the dqlite cluster leader.
	Leader(isNotification bool) (Client, error)

	// Member returns a client to the specified member.
	Member(url *url.URL, isNotification bool, cert *x509.Certificate) (Client, error)

	// RandomMember returns a client to a random member.
	RandomMember(isNotification bool) (Client, error)
}

type Control struct {
	Bootstrap  bool              `json:"bootstrap" yaml:"bootstrap"`
	InitConfig map[string]string `json:"config" yaml:"config"`
	JoinToken  string            `json:"join_token" yaml:"join_token"`
	Address    AddrPort          `json:"address" yaml:"address"`
	Name       string            `json:"name" yaml:"name"`
}

type CtxKey string

type DB interface {
	// Transaction handles performing a transaction on the dqlite database.
	Transaction(outerCtx context.Context, f func(context.Context, *sql.Tx) error) error

	// Leader returns a client connected to the leader of the dqlite cluster.
	Leader(ctx context.Context) (*dqliteClient.Client, error)

	// Cluster returns information about dqlite cluster members.
	Cluster(ctx context.Context, client *dqliteClient.Client) ([]dqliteClient.NodeInfo, error)

	// Status returns the current status of the database.
	Status() DatabaseStatus

	// IsOpen returns nil  only if the DB has been opened and the schema loaded.
	// Otherwise, it returns an error describing why the database is offline.
	// The returned error may have the http status 503, indicating that the database is in a valid but unavailable state.
	IsOpen(ctx context.Context) error

	// SchemaVersion returns the current internal and external schema version, as well as all API extensions in memory.
	SchemaVersion() (versionInternal uint64, versionExternal uint64, apiExtensions Extensions)
}

type DaemonConfig struct {
	Name          string                  `json:"name" yaml:"name"`
	Address       AddrPort                `json:"address" yaml:"address"`
	Servers       map[string]ServerConfig `json:"servers" yaml:"servers"`
	FailureDomain uint64                  `json:"failure-domain" yaml:"failure-domain"`
}

type DaemonConfigPatch struct {
	Servers       *map[string]ServerConfig `json:"servers,omitempty" yaml:"servers,omitempty"`
	FailureDomain *uint64                  `json:"failure-domain,omitempty" yaml:"failure-domain,omitempty"`
}

type DatabaseStatus string

type DqliteMember struct {
	// dqlite.NodeInfo fields
	DqliteID uint64 `json:"id" yaml:"id"`
	Address  string `json:"address" yaml:"address"`
	Role     string `json:"role" yaml:"role"`

	Name string `json:"name" yaml:"name"`
}

type Endpoint struct {
	Name    string          // Name for this endpoint.
	Path    string          // Path pattern for this endpoint.
	Aliases []EndpointAlias // Any aliases for this endpoint.
	Get     EndpointAction
	Put     EndpointAction
	Post    EndpointAction
	Delete  EndpointAction
	Patch   EndpointAction

	AllowedDuringShutdown bool // Whether we should return Unavailable Error (503) if daemon is shutting down.
	AllowedBeforeInit     bool // Whether we should return Unavailabel Error (503) if the daemon has not been initialized (is not yet part of a cluster).
}

type EndpointAction struct {
	Handler        func(state State, r *http.Request) Response
	AccessHandler  func(state State, r *http.Request) (trusted bool, resp Response)
	AllowUntrusted bool
	ProxyTarget    bool // Allow forwarding of the request to a target if ?target=name is specified.
}

type EndpointAlias struct {
	Name string // Name for this alias.
	Path string // Path pattern for this alias.
}

type EndpointPrefix string

type Extensions []string

type HeartbeatInfo struct {
	BeginRound        bool                     `json:"begin_round"         yaml:"begin_round"`
	MaxSchemaInternal uint64                   `json:"max_schema_internal" yaml:"max_schema_internal"`
	MaxSchemaExternal uint64                   `json:"max_schema_external" yaml:"max_schema_external"`
	ClusterMembers    map[string]ClusterMember `json:"cluster_members"     yaml:"cluster_members"`
	LeaderAddress     string                   `json:"leader_address"      yaml:"leader_address"`
	DqliteRoles       map[string]string        `json:"dqlite_roles"        yaml:"dqlite_roles"`
}

type HookNewMemberOptions struct {
	// Name is the name of the new cluster member that joined the cluster, triggering this hook.
	NewMember ClusterMemberLocal `json:"new_member" yaml:"new_member"`
}

type HookRemoveMemberOptions struct {
	// Force represents whether to run the hook with the `force` option.
	Force bool `json:"force" yaml:"force"`
}

type HookType string

type Hooks struct {
	// PreInit is run before the daemon is initialized.
	PreInit func(ctx context.Context, s State, bootstrap bool, initConfig map[string]string) error

	// PostBootstrap is run after the daemon is initialized and bootstrapped.
	PostBootstrap func(ctx context.Context, s State, initConfig map[string]string) error

	// OnStart is run after the daemon is started. Its context will not be cancelled until the daemon is shutting down.
	OnStart func(ctx context.Context, s State) error

	// OnStop is run after the daemon is stopped. Its context is already cancelled but allows access to the logger.
	// The daemon will wait for this hook to complete before exiting.
	OnStop func(ctx context.Context, s State) error

	// PostJoin is run after the daemon is initialized, joined the cluster and existing members triggered
	// their 'OnNewMember' hooks.
	PostJoin func(ctx context.Context, s State, initConfig map[string]string) error

	// PreJoin is run after the daemon is initialized and joined the cluster but before existing members triggered
	// their 'OnNewMember' hooks.
	PreJoin func(ctx context.Context, s State, initConfig map[string]string) error

	// PreRemove is run on a cluster member just before it is removed from the cluster.
	PreRemove func(ctx context.Context, s State, force bool) error

	// PostRemove is run on all other peers after one is removed from the cluster.
	PostRemove func(ctx context.Context, s State, force bool) error

	// OnHeartbeat is run after a successful heartbeat round.
	OnHeartbeat func(ctx context.Context, s State, roleStatus map[string]RoleStatus) error

	// OnNewMember is run on each peer after a new cluster member has joined and executed their 'PreJoin' hook.
	OnNewMember func(ctx context.Context, s State, newMember ClusterMemberLocal) error

	// OnDaemonConfigUpdate is a post-action hook that is run on all cluster members when any cluster member receives a local configuration update.
	OnDaemonConfigUpdate func(ctx context.Context, s State, config DaemonConfig) error
}

type KeyPair struct {
	Cert string `json:"cert" yaml:"cert"`
	Key  string `json:"key" yaml:"key"`
	CA   string `json:"ca" yaml:"ca"`
}

type Location struct {
	Name    string   `yaml:"name"`
	Address AddrPort `yaml:"address"`
}

type MemberStatus string

type OS interface {
	StateDir() string
	DatabaseDir() string
	TrustDir() string
	CertificatesDir() string
	DatabasePath() string
	ControlSocket() *url.URL
	ControlSocketPath() string
	IsControlSocketPresent() (bool, error)
	ServerCert() (*shared.CertInfo, error)
	ClusterCert() (*shared.CertInfo, error)
}

type Remote struct {
	Location    `yaml:",inline"`
	Certificate X509Certificate `yaml:"certificate"`
}

type Resources struct {
	PathPrefix EndpointPrefix
	Endpoints  []Endpoint
}

type Response interface {
	Render(w http.ResponseWriter, r *http.Request) error
	String() string
}

type RoleStatus struct {
	Old string
	New string
}

type SQLBatch struct {
	Results []SQLResult
}

type SQLDump struct {
	Text string `json:"text" yaml:"text"`
}

type SQLQuery struct {
	Query string `json:"query" yaml:"query"`
}

type SQLResult struct {
	Type         string   `json:"type" yaml:"type"`
	Columns      []string `json:"columns" yaml:"columns"`
	Rows         [][]any  `json:"rows" yaml:"rows"`
	RowsAffected int64    `json:"rows_affected" yaml:"rows_affected"`
}

type Server struct {
	ServerConfig

	// CoreAPI determines whether the the resources of the server should be served over the default cluster API.
	CoreAPI bool

	// PreInit determines whether the Server should be available prior to initializing the daemon.
	PreInit bool

	// ServeUnix sets whether the resources of this endpoint should also be served over the unix socket.
	ServeUnix bool

	// DedicatedCertificate sets whether the additional listener should use its own self signed certificate.
	// If false it tries to use a custom certificate from the daemon's state `/certificates` directory
	// based on the name provided when creating the server.
	// In case there isn't any custom certificate it falls back to the cluster certificate of the core API.
	DedicatedCertificate bool

	// Resources is the list of resources offered by this server.
	Resources []Resources

	// DrainConnectionsTimeout is the amount of time to allow for all connections to drain when shutting down.
	// If it's 0, the connections are not drained when shutting down.
	DrainConnectionsTimeout time.Duration
}

type ServerConfig struct {
	// Address is the server listen address.
	// Example: 127.0.0.1:9000
	Address AddrPort `json:"address" yaml:"address"`
}

type State interface {
	// Listen Address.
	Address() *url.URL

	// Name of the cluster member.
	Name() string

	// Version is provided by the MicroCluster consumer.
	Version() string

	// Server certificate is used for server-to-server connection.
	ServerCert() *shared.CertInfo

	// Cluster certificate is used for downstream connections within a cluster.
	ClusterCert() *shared.CertInfo

	// HasExtension returns whether the given API extension is supported.
	HasExtension(ext string) bool

	// ExtensionServers returns an immutable list of the daemon's additional listeners.
	ExtensionServers() []string

	// FileSystem structure.
	FileSystem() OS

	// Database.
	Database() DB

	// Local truststore access.
	Truststore() Store

	// Returns a connector for interconnection with the cluster.
	Connect() Connector
}

type Status struct {
	Name       string     `json:"name"    yaml:"name"`
	Address    AddrPort   `json:"address" yaml:"address"`
	Version    string     `json:"version" yaml:"version"`
	Ready      bool       `json:"ready"   yaml:"ready"`
	Extensions Extensions `json:"extensions" yaml:"extensions"`
}

type Store interface {
	// A list of clients for each of the remotes.
	RemoteClients(isNotification bool, serverCert *shared.CertInfo, publicKey *x509.Certificate) (Clients, error)

	// All remotes keyed by their name.
	RemotesByName() map[string]Remote

	// A specific remote filtered by its address.
	RemoteByAddress(addrPort AddrPort) *Remote

	// All remotes' addresses keyed by their name.
	RemoteAddresses() map[string]AddrPort

	// All remotes' certificates keyed by their name.
	RemoteCertificates() map[string]X509Certificate

	// Same as RemoteCertificates but using the standard libraries type.
	RemoteCertificatesNative() map[string]x509.Certificate

	// The total amount of remotes in the truststore.
	Count() int

	// Add a new remote to the truststore.
	Add(dir string, remotes ...Remote) error

	// Replace remotes in the truststore.
	Replace(dir string, newRemotes ...ClusterMember) error
}

type Token struct {
	// Secret is the underlying secret string used to authenticate the token.
	Secret string `json:"secret" yaml:"secret"`

	// Fingerprint is the fingerprint of the cluster certificate,
	// so that the joiner can verify that the public key of the cluster matches this request.
	Fingerprint string `json:"fingerprint" yaml:"fingerprint"`

	// JoinAddresses is the list of addresses of the existing cluster members that the joiner may supply the token to.
	// Internally, the first system to accept the token will forward it to the dqlite leader.
	JoinAddresses []AddrPort `json:"join_addresses" yaml:"join_addresses"`
}

type TokenRecord struct {
	Name      string    `json:"name" yaml:"name"`
	Token     string    `json:"token" yaml:"token"`
	ExpiresAt time.Time `json:"expires_at" yaml:"expires_at"`
}

type TokenRequest struct {
	Name        string        `json:"name" yaml:"name"`
	ExpireAfter time.Duration `json:"expire_after" yaml:"expire_after"`
}

type TokenResponse struct {
	// ClusterCert is the public key used across the cluster.
	ClusterCert X509Certificate `json:"cluster_cert" yaml:"cluster_cert"`

	// ClusterKey is the private key used across the cluster.
	ClusterKey string `json:"cluster_key" yaml:"cluster_key"`

	// ClusterMembers is the full list of cluster members that are currently present and available in the cluster.
	// The joiner supplies this list to dqlite so that it can start its database.
	ClusterMembers []ClusterMemberLocal `json:"cluster_members" yaml:"cluster_members"`

	// ClusterAdditionalCerts is the full list of certificates added for additional listeners.
	ClusterAdditionalCerts map[string]KeyPair

	// TrustedMember contains the address of the existing cluster member
	// who was dqlite leader at the time that the joiner supplied its join token.
	//
	// The trusted member will have already recorded the joiner's information in
	// its local truststore, and thus will trust requests from the joiner prior to fully joining.
	TrustedMember ClusterMemberLocal `json:"trusted_member" yaml:"trusted_member"`
}

type X509Certificate struct {
	*x509.Certificate
}