domain

type Application struct {
	ID            string
	Name          string
	RepositoryID  string
	RefName       string
	DeployType    DeployType
	Running       bool
	Container     ContainerState
	CurrentCommit string
	WantCommit    string
	CreatedAt     time.Time
	UpdatedAt     time.Time

	Config           ApplicationConfig
	Websites         []*Website
	PortPublications []*PortPublication
	OwnerIDs         []string
}

type ApplicationConfig struct {
	BuildConfig BuildConfig
}

type ApplicationRepository interface {
	GetApplications(ctx context.Context, cond GetApplicationCondition) ([]*Application, error)
	GetApplication(ctx context.Context, id string) (*Application, error)
	CreateApplication(ctx context.Context, app *Application) error
	UpdateApplication(ctx context.Context, id string, args *UpdateApplicationArgs) error
	BulkUpdateState(ctx context.Context, m map[string]ContainerState) error
	DeleteApplication(ctx context.Context, id string) error
}

type Artifact struct {
	ID        string
	BuildID   string
	Size      int64
	CreatedAt time.Time
	DeletedAt optional.Of[time.Time]
}

type ArtifactRepository interface {
	GetArtifacts(ctx context.Context, cond GetArtifactCondition) ([]*Artifact, error)
	CreateArtifact(ctx context.Context, artifact *Artifact) error
	UpdateArtifact(ctx context.Context, id string, args UpdateArtifactArgs) error
	HardDeleteArtifacts(ctx context.Context, cond GetArtifactCondition) error
}

type AuthenticationType int

type AvailableDomain struct {
	Domain         string
	ExcludeDomains []string
	AuthAvailable  bool
}

type AvailableDomainSlice []*AvailableDomain

type AvailablePort struct {
	StartPort int
	EndPort   int
	Protocol  PortPublicationProtocol
}

type AvailablePortSlice []*AvailablePort

type AvatarBaseURL string

type Backend interface {
	Start(ctx context.Context) error
	Dispose(ctx context.Context) error

	AvailableDomains() AvailableDomainSlice
	AvailablePorts() AvailablePortSlice
	ListenContainerEvents() (sub <-chan *ContainerEvent, unsub func())
	Synchronize(ctx context.Context, s *DesiredState) error
	GetContainer(ctx context.Context, appID string) (*Container, error)
	ListContainers(ctx context.Context) ([]*Container, error)
	ExecContainer(ctx context.Context, appID string, cmd []string, stdin io.Reader, stdout, stderr io.Writer) error
}

type Build struct {
	ID            string
	Commit        string
	Status        BuildStatus
	ApplicationID string
	QueuedAt      time.Time
	StartedAt     optional.Of[time.Time]
	UpdatedAt     optional.Of[time.Time]
	FinishedAt    optional.Of[time.Time]
	Retriable     bool
	Artifact      optional.Of[Artifact]
}

type BuildConfig interface {
	BuildType() BuildType
	Validate() error
	MariaDB() bool
	MongoDB() bool
	EntrypointArgs() []string
	CommandArgs() []string
	// contains filtered or unexported methods
}

type BuildConfigRuntimeBuildpack struct {
	RuntimeConfig
	Context string
	// contains filtered or unexported fields
}

type BuildConfigRuntimeCmd struct {
	RuntimeConfig
	BaseImage     string
	BuildCmd      string
	BuildCmdShell bool
	// contains filtered or unexported fields
}

type BuildConfigRuntimeDockerfile struct {
	RuntimeConfig
	DockerfileName string
	Context        string
	// contains filtered or unexported fields
}

type BuildConfigStaticCmd struct {
	StaticConfig
	BaseImage     string
	BuildCmd      string
	BuildCmdShell bool
	ArtifactPath  string
	// contains filtered or unexported fields
}

type BuildConfigStaticDockerfile struct {
	StaticConfig
	DockerfileName string
	Context        string
	ArtifactPath   string
	// contains filtered or unexported fields
}

type BuildRepository interface {
	GetBuilds(ctx context.Context, cond GetBuildCondition) ([]*Build, error)
	GetBuild(ctx context.Context, buildID string) (*Build, error)
	CreateBuild(ctx context.Context, build *Build) error
	UpdateBuild(ctx context.Context, id string, args UpdateBuildArgs) error
	MarkCommitAsRetriable(ctx context.Context, applicationID string, commit string) error
	DeleteBuilds(ctx context.Context, cond GetBuildCondition) error
}

type BuildStatus int

type BuildType int

type Container struct {
	ApplicationID string
	State         ContainerState
}

type ContainerEvent struct {
	ApplicationID string
}

type ContainerLog struct {
	Time time.Time
	Log  string
}

type ContainerLogger interface {
	Stream(ctx context.Context, appID string) (<-chan *ContainerLog, error)
}

type ContainerState int

type ControllerBuilderService interface {
	pbconnect.ControllerBuilderServiceHandler
	ListenBuilderIdle() (sub <-chan struct{}, unsub func())
	ListenBuildSettled() (sub <-chan struct{}, unsub func())
	StartBuilds(buildIDs []string)
	BroadcastBuilder(req *pb.BuilderRequest)
}

type ControllerBuilderServiceClient interface {
	ConnectBuilder(ctx context.Context, onRequest func(req *pb.BuilderRequest), response <-chan *pb.BuilderResponse) error
}

type ControllerSSGenService interface {
	pbconnect.ControllerSSGenServiceHandler
	BroadcastSSGen(req *pb.SSGenRequest)
}

type ControllerSSGenServiceClient interface {
	ConnectSSGen(ctx context.Context, onRequest func(req *pb.SSGenRequest)) error
}

type ControllerServiceClient interface {
	GetSSHInfo(ctx context.Context) (host string, port int, err error)
	GetAvailableDomains(ctx context.Context) (AvailableDomainSlice, error)
	GetAvailablePorts(ctx context.Context) (AvailablePortSlice, error)

	FetchRepository(ctx context.Context, repositoryID string) error
	RegisterBuild(ctx context.Context, appID string) error
	SyncDeployments(ctx context.Context) error
	StreamBuildLog(ctx context.Context, buildID string) (<-chan *pb.BuildLog, error)
	CancelBuild(ctx context.Context, buildID string) error
}

type CreateArgs struct {
	// Database データベース/ユーザー名
	Database string
	// Password アクセスパスワード
	Password string
}

type CreateUserArgs struct {
	Name string
}

type DeleteArgs struct {
	// Database データベース/ユーザー名
	Database string
}

type DeployType int

type DesiredState struct {
	Runtime     []*RuntimeDesiredState
	StaticSites []*StaticSite
}

type Environment struct {
	ApplicationID string
	Key           string
	Value         string
	System        bool
}

type EnvironmentRepository interface {
	GetEnv(ctx context.Context, cond GetEnvCondition) ([]*Environment, error)
	SetEnv(ctx context.Context, env *Environment) error
	DeleteEnv(ctx context.Context, cond GetEnvCondition) error
}

type GetApplicationCondition struct {
	IDIn         optional.Of[[]string]
	RepositoryID optional.Of[string]
	UserID       optional.Of[string]
	DeployType   optional.Of[DeployType]
	Running      optional.Of[bool]
	// InSync WantCommit が CurrentCommit に一致する
	InSync optional.Of[bool]
}

type GetArtifactCondition struct {
	ApplicationID optional.Of[string]
	IsDeleted     optional.Of[bool]
}

type GetBuildCondition struct {
	ApplicationID optional.Of[string]
	Commit        optional.Of[string]
	CommitIn      optional.Of[[]string]
	Status        optional.Of[BuildStatus]
	Retriable     optional.Of[bool]
}

type GetEnvCondition struct {
	ApplicationIDIn optional.Of[[]string]
	ApplicationID   optional.Of[string]
	Key             optional.Of[string]
}

type GetRepositoryCondition struct {
	IDs             optional.Of[[]string]
	URLs            optional.Of[[]string]
	PublicOrOwnedBy optional.Of[string]
	UserID          optional.Of[string]
}

type GetUserCondition struct {
	Admin optional.Of[bool]
}

type GetUserKeyCondition struct {
	UserIDs optional.Of[[]string]
}

type GitRepositoryRepository interface {
	GetRepositories(ctx context.Context, condition GetRepositoryCondition) ([]*Repository, error)
	GetRepository(ctx context.Context, id string) (*Repository, error)
	CreateRepository(ctx context.Context, repo *Repository) error
	UpdateRepository(ctx context.Context, id string, args *UpdateRepositoryArgs) error
	DeleteRepository(ctx context.Context, id string) error
}

type MariaDBManager interface {
	GetHost() (host string, port int)
	// Create データベースが存在しない場合、作成します
	Create(ctx context.Context, args CreateArgs) error
	// Delete データベースが存在する場合、削除します
	Delete(ctx context.Context, args DeleteArgs) error
	// IsExist データベースが存在するか確認します
	IsExist(ctx context.Context, dbname string) (bool, error)
	Close(ctx context.Context) error
}

type MongoDBManager interface {
	GetHost() (host string, port int)
	// Create データベースが存在しない場合、作成します
	Create(ctx context.Context, args CreateArgs) error
	// Delete データベースが存在する場合、削除します
	Delete(ctx context.Context, args DeleteArgs) error
	// IsExist データベースが存在するか確認します
	IsExist(ctx context.Context, dbname string) (bool, error)
	Close(ctx context.Context) error
}

type PortPublication struct {
	InternetPort    int
	ApplicationPort int
	Protocol        PortPublicationProtocol
}

type PortPublicationProtocol string

type PubSub[E any] struct {
	// contains filtered or unexported fields
}

type Repository struct {
	ID       string
	Name     string
	URL      string
	Auth     optional.Of[RepositoryAuth]
	OwnerIDs []string
}

type RepositoryAuth struct {
	Method   RepositoryAuthMethod
	Username string
	Password string
	SSHKey   string
}

type RepositoryAuthMethod int

type RuntimeConfig struct {
	UseMariaDB bool
	UseMongoDB bool
	Entrypoint string
	Command    string
}

type RuntimeDesiredState struct {
	App       *Application
	ImageName string
	ImageTag  string
	Envs      map[string]string
}

type SSHConfig struct {
	Host string `mapstructure:"host" yaml:"host"`
	Port int    `mapstructure:"port" yaml:"port"`
}

type StaticConfig struct{}

type StaticServer interface {
	Start(ctx context.Context) error
	Reconcile(sites []*StaticSite) error
	Shutdown(ctx context.Context) error
}

type StaticServerDocumentRootPath string

type StaticSite struct {
	Application *Application
	Website     *Website
	ArtifactID  string
}

type Storage interface {
	Save(filename string, src io.Reader) error
	Open(filename string) (io.ReadCloser, error)
	Delete(filename string) error
}

type StorageConfig struct {
	Type  string `mapstructure:"type" yaml:"type"`
	Local struct {
		// Dir 保存ディレクトリ
		Dir string `mapstructure:"dir" yaml:"dir"`
	} `mapstructure:"local" yaml:"local"`
	S3 struct {
		// Bucket バケット名
		Bucket       string `mapstructure:"bucket" yaml:"bucket"`
		Endpoint     string `mapstructure:"endpoint" yaml:"endpoint"`
		Region       string `mapstructure:"region" yaml:"region"`
		AccessKey    string `mapstructure:"accessKey" yaml:"accessKey"`
		AccessSecret string `mapstructure:"accessSecret" yaml:"accessSecret"`
	} `mapstructure:"s3" yaml:"s3"`
	Swift struct {
		// UserName ユーザー名
		UserName string `mapstructure:"username" yaml:"username"`
		// APIKey APIキー(パスワード)
		APIKey string `mapstructure:"apiKey" yaml:"apiKey"`
		// TenantName テナント名
		TenantName string `mapstructure:"tenantName" yaml:"tenantName"`
		// TenantID テナントID
		TenantID string `mapstructure:"tenantId" yaml:"tenantId"`
		// Container コンテナ名
		Container string `mapstructure:"container" yaml:"container"`
		// AuthURL 認証エンドポイント
		AuthURL string `mapstructure:"authUrl" yaml:"authUrl"`
	} `mapstructure:"swift" yaml:"swift"`
}

type UpdateApplicationArgs struct {
	Name             optional.Of[string]
	RefName          optional.Of[string]
	Running          optional.Of[bool]
	Container        optional.Of[ContainerState]
	CurrentCommit    optional.Of[string]
	WantCommit       optional.Of[string]
	UpdatedAt        optional.Of[time.Time]
	Config           optional.Of[ApplicationConfig]
	Websites         optional.Of[[]*Website]
	PortPublications optional.Of[[]*PortPublication]
	OwnerIDs         optional.Of[[]string]
}

type UpdateArtifactArgs struct {
	DeletedAt optional.Of[time.Time]
}

type UpdateBuildArgs struct {
	FromStatus optional.Of[BuildStatus]
	Status     optional.Of[BuildStatus]
	StartedAt  optional.Of[time.Time]
	UpdatedAt  optional.Of[time.Time]
	FinishedAt optional.Of[time.Time]
}

type UpdateRepositoryArgs struct {
	Name     optional.Of[string]
	URL      optional.Of[string]
	Auth     optional.Of[optional.Of[RepositoryAuth]]
	OwnerIDs optional.Of[[]string]
}

type User struct {
	ID    string
	Name  string
	Admin bool
}

type UserKey struct {
	ID        string
	UserID    string
	PublicKey string
}

type UserRepository interface {
	EnsureUser(ctx context.Context, name string) (*User, error)
	EnsureUsers(ctx context.Context, names []string) ([]*User, error)
	GetUsers(ctx context.Context, cond GetUserCondition) ([]*User, error)
	GetUserKeys(ctx context.Context, cond GetUserKeyCondition) ([]*UserKey, error)
	CreateUserKey(ctx context.Context, key *UserKey) error
	DeleteUserKey(ctx context.Context, keyID string, userID string) error
}

type Website struct {
	ID             string
	FQDN           string
	PathPrefix     string
	StripPrefix    bool
	HTTPS          bool
	H2C            bool
	HTTPPort       int
	Authentication AuthenticationType
}

type WildcardDomains []string