dbng

type BaseResourceType struct {
	Name string // The name of the type, e.g. 'git'.
}

type BaseResourceTypeFactory interface {
	Find(name string) (*UsedBaseResourceType, bool, error)
}

type Build interface {
	ID() int
	SaveStatus(s BuildStatus) error
	Finish(s BuildStatus) error
	Delete() (bool, error)
	SaveImageResourceVersion(planID atc.PlanID, resourceVersion atc.Version, resourceHash string) error
}

type BuildStatus string

type ConfigVersion int

type Conn interface {
	Begin() (Tx, error)
	Close() error
	Driver() driver.Driver
	Exec(query string, args ...interface{}) (sql.Result, error)
	Ping() error
	Prepare(query string) (*sql.Stmt, error)
	Query(query string, args ...interface{}) (*sql.Rows, error)
	QueryRow(query string, args ...interface{}) *sql.Row
	SetMaxIdleConns(n int)
	SetMaxOpenConns(n int)
	Stats() sql.DBStats
}

type ContainerFactory interface {
	FindContainersMarkedForDeletion() ([]DestroyingContainer, error)
	MarkContainersForDeletion() error
	FindHijackedContainersForDeletion() ([]CreatedContainer, error)
}

type ContainerMetadata struct {
	Type string
	Name string
}

type ContainerStage string

type ContainerState string

type CreatedContainer interface {
	ID() int
	Handle() string
	Discontinue() (DestroyingContainer, error)
	Destroying() (DestroyingContainer, error)
	WorkerName() string
	MarkAsHijacked() error
}

type CreatedVolume interface {
	Handle() string
	Path() string
	Type() VolumeType
	CreateChildForContainer(CreatingContainer, string) (CreatingVolume, error)
	Destroying() (DestroyingVolume, error)
	Worker() *Worker
	SizeInBytes() int64
	Initialize() error
	IsInitialized() (bool, error)
	ContainerHandle() string
	ParentHandle() string
	ResourceType() (*VolumeResourceType, error)
	BaseResourceType() (*WorkerBaseResourceType, error)
}

type CreatingContainer interface {
	ID() int
	Handle() string
	Created() (CreatedContainer, error)
}

type CreatingVolume interface {
	Handle() string
	ID() int
	Created() (CreatedVolume, error)
}

type DestroyingContainer interface {
	Handle() string
	WorkerName() string
	Destroy() (bool, error)
	IsDiscontinued() bool
}

type DestroyingVolume interface {
	Handle() string
	Destroy() (bool, error)
	Worker() *Worker
}

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

type ErrVolumeMarkCreatedFailed struct {
	Handle string
}

type Pipeline interface {
	ID() int
	SaveJob(job atc.JobConfig) error
	CreateJobBuild(jobName string) (Build, error)
	CreateResource(name string, config atc.ResourceConfig) (*Resource, error)
	AcquireResourceCheckingLock(
		logger lager.Logger,
		resource *Resource,
		resourceTypes atc.ResourceTypes,
		length time.Duration,
		immediate bool,
	) (lock.Lock, bool, error)
	Destroy() error
}

type PipelineFactory interface {
	GetPipelineByID(teamID int, pipelineID int) Pipeline
}

type PipelinePausedState string

type Resource struct {
	ID     int
	Name   string
	Type   string
	Source atc.Source
}

type ResourceCache struct {
	ResourceConfig ResourceConfig // The resource configuration.
	Version        atc.Version    // The version of the resource.
	Params         atc.Params     // The params used when fetching the version.
}

type ResourceCacheFactory interface {
	FindOrCreateResourceCacheForBuild(
		logger lager.Logger,
		buildID int,
		resourceTypeName string,
		version atc.Version,
		source atc.Source,
		params atc.Params,
		pipelineID int,
		resourceTypes atc.ResourceTypes,
	) (*UsedResourceCache, error)

	FindOrCreateResourceCacheForResource(
		logger lager.Logger,
		resourceID int,
		resourceTypeName string,
		version atc.Version,
		source atc.Source,
		params atc.Params,
		pipelineID int,
		resourceTypes atc.ResourceTypes,
	) (*UsedResourceCache, error)

	FindOrCreateResourceCacheForResourceType(
		logger lager.Logger,
		resourceTypeName string,
		version atc.Version,
		source atc.Source,
		params atc.Params,
		pipelineID int,
		resourceTypes atc.ResourceTypes,
	) (*UsedResourceCache, error)

	CleanUsesForFinishedBuilds() error
	CleanUsesForInactiveResourceTypes() error
	CleanUsesForInactiveResources() error

	CleanUpInvalidCaches() error
}

type ResourceConfig struct {
	// A resource type provided by a resource.
	CreatedByResourceCache *ResourceCache

	// A resource type provided by a worker.
	CreatedByBaseResourceType *BaseResourceType

	// The resource's source configuration.
	Source atc.Source
}

type ResourceConfigFactory interface {
	FindOrCreateResourceConfigForBuild(
		logger lager.Logger,
		buildID int,
		resourceType string,
		source atc.Source,
		pipelineID int,
		resourceTypes atc.ResourceTypes,
	) (*UsedResourceConfig, error)

	FindOrCreateResourceConfigForResource(
		logger lager.Logger,
		resourceID int,
		resourceType string,
		source atc.Source,
		pipelineID int,
		resourceTypes atc.ResourceTypes,
	) (*UsedResourceConfig, error)

	FindOrCreateResourceConfigForResourceType(
		logger lager.Logger,
		resourceTypeName string,
		source atc.Source,
		pipelineID int,
		resourceTypes atc.ResourceTypes,
	) (*UsedResourceConfig, error)

	CleanConfigUsesForFinishedBuilds() error
	CleanConfigUsesForInactiveResourceTypes() error
	CleanConfigUsesForInactiveResources() error
	CleanUselessConfigs() error
}

type ResourceType struct {
	atc.ResourceType

	PipelineID int
}

type ResourceTypeFactory interface {
	FindResourceType(pipelineID int, resourceType atc.ResourceType) (*UsedResourceType, bool, error)
	CreateResourceType(pipelineID int, resourceType atc.ResourceType, version atc.Version) (*UsedResourceType, error)
}

type Team interface {
	ID() int
	SavePipeline(
		pipelineName string,
		config atc.Config,
		from ConfigVersion,
		pausedState PipelinePausedState,
	) (Pipeline, bool, error)

	FindPipelineByName(pipelineName string) (Pipeline, bool, error)

	CreateOneOffBuild() (Build, error)

	SaveWorker(worker atc.Worker, ttl time.Duration) (*Worker, error)

	FindContainerByHandle(string) (CreatedContainer, bool, error)

	FindResourceCheckContainer(*Worker, *UsedResourceConfig) (CreatingContainer, CreatedContainer, error)
	CreateResourceCheckContainer(*Worker, *UsedResourceConfig) (CreatingContainer, error)

	FindResourceGetContainer(*Worker, *UsedResourceCache, string) (CreatingContainer, CreatedContainer, error)
	CreateResourceGetContainer(*Worker, *UsedResourceCache, string) (CreatingContainer, error)

	FindBuildContainer(*Worker, int, atc.PlanID, ContainerMetadata) (CreatingContainer, CreatedContainer, error)
	CreateBuildContainer(*Worker, int, atc.PlanID, ContainerMetadata) (CreatingContainer, error)
}

type TeamFactory interface {
	CreateTeam(name string) (Team, error)
	FindTeam(name string) (Team, bool, error)
	GetByID(teamID int) Team
}

type Tx interface {
	Commit() error
	Exec(query string, args ...interface{}) (sql.Result, error)
	Prepare(query string) (*sql.Stmt, error)
	Query(query string, args ...interface{}) (*sql.Rows, error)
	QueryRow(query string, args ...interface{}) *sql.Row
	Rollback() error
	Stmt(stmt *sql.Stmt) *sql.Stmt
}

type UsedBaseResourceType struct {
	ID int // The ID of the BaseResourceType.
}

type UsedResourceCache struct {
	ID             int
	ResourceConfig *UsedResourceConfig
	Version        atc.Version
}

type UsedResourceConfig struct {
	ID                        int
	CreatedByResourceCache    *UsedResourceCache
	CreatedByBaseResourceType *UsedBaseResourceType
}

type UsedResourceType struct {
	ID      int
	Version atc.Version
}

type UsedWorkerResourceType struct {
	ID int

	Worker *Worker

	UsedBaseResourceType *UsedBaseResourceType
}

type VolumeFactory interface {
	GetTeamVolumes(teamID int) ([]CreatedVolume, error)

	CreateContainerVolume(int, *Worker, CreatingContainer, string) (CreatingVolume, error)
	FindContainerVolume(int, *Worker, CreatingContainer, string) (CreatingVolume, CreatedVolume, error)

	FindBaseResourceTypeVolume(int, *Worker, *UsedBaseResourceType) (CreatingVolume, CreatedVolume, error)
	CreateBaseResourceTypeVolume(int, *Worker, *UsedBaseResourceType) (CreatingVolume, error)

	FindResourceCacheVolume(*Worker, *UsedResourceCache) (CreatingVolume, CreatedVolume, error)
	FindResourceCacheInitializedVolume(*Worker, *UsedResourceCache) (CreatedVolume, bool, error)
	CreateResourceCacheVolume(*Worker, *UsedResourceCache) (CreatingVolume, error)

	FindVolumesForContainer(CreatedContainer) ([]CreatedVolume, error)
	GetOrphanedVolumes() ([]CreatedVolume, []DestroyingVolume, error)

	FindCreatedVolume(handle string) (CreatedVolume, bool, error)
}

type VolumeResourceType struct {
	BaseResourceType *WorkerBaseResourceType
	ResourceType     *VolumeResourceType
	Version          atc.Version
}

type VolumeState string

type VolumeType string

type Worker struct {
	Name       string
	GardenAddr *string
	State      WorkerState

	BaggageclaimURL *string
	HTTPProxyURL    string
	HTTPSProxyURL   string
	NoProxy         string

	ActiveContainers int
	ResourceTypes    []atc.WorkerResourceType
	Platform         string
	Tags             []string
	TeamID           int
	StartTime        int64

	TeamName  string
	ExpiresIn time.Duration
}

type WorkerBaseResourceType struct {
	ID      int
	Name    string
	Version string
}

type WorkerFactory interface {
	GetWorker(name string) (*Worker, bool, error)
	Workers() ([]*Worker, error)
	WorkersForTeam(teamName string) ([]*Worker, error)
	StallWorker(name string) (*Worker, error)
	StallUnresponsiveWorkers() ([]*Worker, error)
	DeleteFinishedRetiringWorkers() error
	LandFinishedLandingWorkers() error
	SaveWorker(worker atc.Worker, ttl time.Duration) (*Worker, error)
	LandWorker(name string) (*Worker, error)
	RetireWorker(name string) (*Worker, error)
	PruneWorker(name string) error
	DeleteWorker(name string) error
	HeartbeatWorker(worker atc.Worker, ttl time.Duration) (*Worker, error)
}

type WorkerResourceType struct {
	Worker  *Worker
	Image   string // The path to the image, e.g. '/opt/concourse/resources/git'.
	Version string // The version of the image, e.g. a SHA of the rootfs.

	BaseResourceType *BaseResourceType
}

type WorkerState string