db

package
v3.3.3+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 20, 2017 License: Apache-2.0 Imports: 28 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	NoVerionsSatisfiedPassedConstraints string = "no versions satisfy passed constraints"
	NoVersionsAvailable                 string = "no versions available"
	PinnedVersionUnavailable            string = "pinned version %s is not available"
)
View Source 
const (
	ContainerStateCreating   = "creating"
	ContainerStateCreated    = "created"
	ContainerStateDestroying = "destroying"
)
View Source 
const (
	WorkerStateRunning  = WorkerState("running")
	WorkerStateStalled  = WorkerState("stalled")
	WorkerStateLanding  = WorkerState("landing")
	WorkerStateLanded   = WorkerState("landed")
	WorkerStateRetiring = WorkerState("retiring")
)

Variables

View Source 
var (
	ErrVolumeMarkDestroyingFailed                 = errors.New("could not mark volume as destroying")
	ErrVolumeCannotBeDestroyedWithChildrenPresent = errors.New("volume cannot be destroyed as children are present")
	ErrVolumeStateTransitionFailed                = errors.New("could not transition volume state")
	ErrVolumeMissing                              = errors.New("volume no longer in db")
	ErrInvalidResourceCache                       = errors.New("invalid resource cache")
)
View Source 
var (
	ErrWorkerNotPresent         = errors.New("worker-not-present-in-db")
	ErrCannotPruneRunningWorker = errors.New("worker-not-stalled-for-pruning")
)
View Source 
var ErrBaseResourceTypeAlreadyExists = errors.New("base-resource-type-already-exists")
View Source 
var ErrBaseResourceTypeNotFound = errors.New("base resource type not found")
View Source 
var ErrBuildDisappeared = errors.New("build-disappeared-from-db")
View Source 
var ErrBuildEventStreamClosed = errors.New("build event stream closed")
View Source 
var ErrConfigComparisonFailed = errors.New("comparison with existing config failed during save")
View Source 
var ErrContainerDisappeared = errors.New("container disappeared from db")
View Source 
var ErrDataIsEncrypted = errors.New("failed to decrypt data that is encrypted")
View Source 
var ErrDataIsNotEncrypted = errors.New("failed to decrypt data that is not encrypted")
View Source 
var ErrEncryptedWithUnknownKey = errors.New("row encrypted with neither old nor new key")
View Source 
var ErrEndOfBuildEventStream = errors.New("end of build event stream")
View Source 
var ErrResourceCacheAlreadyExists = errors.New("resource-cache-already-exists")
View Source 
var ErrResourceCacheDisappeared = errors.New("resource-cache-disappeared")
View Source 
var ErrResourceConfigAlreadyExists = errors.New("resource config already exists")
View Source 
var ErrResourceConfigDisappeared = errors.New("resource config disappeared")
View Source 
var ErrResourceConfigParentDisappeared = errors.New("resource config parent disappeared")
View Source 
var ErrSafeRetryCreateOrUpdate = errors.New("failed-to-run-safe-create-or-update-retrying")
View Source 
var ErrSafeRetryFindOrCreate = errors.New("failed-to-run-safe-find-or-create-retrying")
View Source 
var ErrWorkerBaseResourceTypeDisappeared = errors.New("worker base resource type disappeared")
View Source 
var ErrWorkerResourceTypeNotFound = errors.New("worker resource type no longer exists (stale?)")

Functions

func NewNotificationsBus 

func NewNotificationsBus(listener *pq.Listener, conn *sql.DB) *notificationsBus

func SetupConnectionRetryingDriver 

func SetupConnectionRetryingDriver(delegateDriverName, sqlDataSource, newDriverName string)

Types

type BaseResourceType 

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

BaseResourceType represents a resource type provided by workers.

It is created via worker registration. All creates are upserts.

It is removed by gc.BaseResourceTypeCollector, once there are no references to it from worker_base_resource_types.

func (BaseResourceType) Find 

func (brt BaseResourceType) Find(tx Tx) (*UsedBaseResourceType, bool, error)

func (BaseResourceType) FindOrCreate 

func (brt BaseResourceType) FindOrCreate(tx Tx) (*UsedBaseResourceType, error)

FindOrCreate looks for an existing BaseResourceType and creates it if it doesn't exist. It returns a UsedBaseResourceType.

Note that if the BaseResourceType already existed, there's a chance that it will be garbage-collected before the referencing ResourceConfig can be created and used.

This method can return ErrBaseResourceTypeAlreadyExists if two concurrent FindOrCreates clashed. The caller should retry from the start of the transaction.

type BaseResourceTypeFactory 

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

func NewBaseResourceTypeFactory 

func NewBaseResourceTypeFactory(conn Conn) BaseResourceTypeFactory

type Build 

type Build interface {
	ID() int
	Name() string
	JobID() int
	JobName() string
	PipelineID() int
	PipelineName() string
	TeamID() int
	TeamName() string
	Engine() string
	EngineMetadata() string
	PublicPlan() *json.RawMessage
	Status() BuildStatus
	StartTime() time.Time
	EndTime() time.Time
	ReapTime() time.Time
	IsManuallyTriggered() bool
	IsScheduled() bool

	IsRunning() bool

	Reload() (bool, error)

	Interceptible() (bool, error)
	AcquireTrackingLock(logger lager.Logger, interval time.Duration) (lock.Lock, bool, error)
	Preparation() (BuildPreparation, bool, error)

	Start(string, string, atc.Plan) (bool, error)
	FinishWithError(cause error) error
	Finish(BuildStatus) error

	SetInterceptible(bool) error

	Events(uint) (EventSource, error)
	SaveEvent(event atc.Event) error

	SaveInput(input BuildInput) error
	SaveOutput(vr VersionedResource, explicit bool) error
	UseInputs(inputs []BuildInput) error

	Resources() ([]BuildInput, []BuildOutput, error)
	GetVersionedResources() (SavedVersionedResources, error)
	SaveImageResourceVersion(*UsedResourceCache) error

	Pipeline() (Pipeline, bool, error)

	Delete() (bool, error)
	MarkAsAborted() error
	AbortNotifier() (Notifier, error)
	Schedule() (bool, error)
}

type BuildFactory 

type BuildFactory interface {
	Build(int) (Build, bool, error)
	PublicBuilds(Page) ([]Build, Pagination, error)
	GetAllStartedBuilds() ([]Build, error)

	// TODO: move to BuildLifecycle, new interface (see WorkerLifecycle)
	MarkNonInterceptibleBuilds() error
}

func NewBuildFactory 

func NewBuildFactory(conn Conn, lockFactory lock.LockFactory) BuildFactory

type BuildInput 

type BuildInput struct {
	Name string

	VersionedResource

	FirstOccurrence bool
}

type BuildOutput 

type BuildOutput struct {
	VersionedResource
}

type BuildPreparation 

type BuildPreparation struct {
	BuildID             int
	PausedPipeline      BuildPreparationStatus
	PausedJob           BuildPreparationStatus
	MaxRunningBuilds    BuildPreparationStatus
	Inputs              map[string]BuildPreparationStatus
	InputsSatisfied     BuildPreparationStatus
	MissingInputReasons MissingInputReasons
}

type BuildPreparationStatus 

type BuildPreparationStatus string
const (
	BuildPreparationStatusUnknown     BuildPreparationStatus = "unknown"
	BuildPreparationStatusBlocking    BuildPreparationStatus = "blocking"
	BuildPreparationStatusNotBlocking BuildPreparationStatus = "not_blocking"
)

type BuildStatus 

type BuildStatus string
const (
	BuildStatusPending   BuildStatus = "pending"
	BuildStatusStarted   BuildStatus = "started"
	BuildStatusAborted   BuildStatus = "aborted"
	BuildStatusSucceeded BuildStatus = "succeeded"
	BuildStatusFailed    BuildStatus = "failed"
	BuildStatusErrored   BuildStatus = "errored"
)

type ConfigVersion 

type ConfigVersion int

ConfigVersion is a sequence identifier used for compare-and-swap

type Conn 

type Conn interface {
	Bus() NotificationsBus
	EncryptionStrategy() EncryptionStrategy

	Begin() (Tx, 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{}) squirrel.RowScanner
	SetMaxIdleConns(n int)
	SetMaxOpenConns(n int)
	Stats() sql.DBStats

	Close() error
}

func Log 

func Log(logger lager.Logger, conn Conn) Conn

func Open 

func Open(logger lager.Logger, sqlDriver string, sqlDataSource string, newKey *EncryptionKey, oldKey *EncryptionKey) (Conn, error)

type Container 

type Container interface {
	ID() int
	Handle() string
	WorkerName() string
	Metadata() ContainerMetadata
}

type ContainerFactory 

type ContainerFactory interface {
	FindContainersForDeletion() ([]CreatingContainer, []CreatedContainer, []DestroyingContainer, error)
}

func NewContainerFactory 

func NewContainerFactory(conn Conn) ContainerFactory

type ContainerMetadata 

type ContainerMetadata struct {
	Type ContainerType

	StepName string
	Attempt  string

	WorkingDirectory string
	User             string

	PipelineID int
	JobID      int
	BuildID    int

	PipelineName string
	JobName      string
	BuildName    string
}

func (ContainerMetadata) SQLMap 

func (metadata ContainerMetadata) SQLMap() map[string]interface{}

func (*ContainerMetadata) ScanTargets 

func (metadata *ContainerMetadata) ScanTargets() []interface{}

type ContainerOwner 

type ContainerOwner interface {
	Find(conn Conn) (sq.Eq, bool, error)
	Create(tx Tx, workerName string) (map[string]interface{}, error)
}

ContainerOwner designates the data the container should reference that identifies its lifecycle. When the owner goes away, the container should be garbage collected.

func NewBuildStepContainerOwner 

func NewBuildStepContainerOwner(
	buildID int,
	planID atc.PlanID,
) ContainerOwner

NewBuildStepContainerOwner references a step within a build. When the build becomes non-interceptible or disappears, the container can be removed.

func NewImageCheckContainerOwner 

func NewImageCheckContainerOwner(
	container CreatingContainer,
) ContainerOwner

NewImageCheckContainerOwner references a container whose image resource this container is checking. When the referenced container transitions to another state, or disappears, the container can be removed.

func NewImageGetContainerOwner 

func NewImageGetContainerOwner(
	container CreatingContainer,
) ContainerOwner

NewImageGetContainerOwner references a container whose image resource this container is fetching. When the referenced container transitions to another state, or disappears, the container can be removed.

func NewResourceConfigCheckSessionContainerOwner 

func NewResourceConfigCheckSessionContainerOwner(
	resourceConfig *UsedResourceConfig,
) ContainerOwner

NewResourceConfigCheckSessionContainerOwner references a resource config and worker base resource type, with an expiry. When the resource config or worker base resource type disappear, or the expiry is reached, the container can be removed.

type ContainerState 

type ContainerState string

type ContainerType 

type ContainerType string
const (
	ContainerTypeCheck ContainerType = "check"
	ContainerTypeGet   ContainerType = "get"
	ContainerTypePut   ContainerType = "put"
	ContainerTypeTask  ContainerType = "task"
)

func ContainerTypeFromString 

func ContainerTypeFromString(containerType string) (ContainerType, error)

type CreatedContainer 

type CreatedContainer interface {
	Container

	Discontinue() (DestroyingContainer, error)
	Destroying() (DestroyingContainer, error)
	IsHijacked() bool
	MarkAsHijacked() error
}

type CreatedVolume 

type CreatedVolume interface {
	Handle() string
	Path() string
	Type() VolumeType
	TeamID() int
	CreateChildForContainer(CreatingContainer, string) (CreatingVolume, error)
	Destroying() (DestroyingVolume, error)
	WorkerName() string
	SizeInBytes() int64
	InitializeResourceCache(*UsedResourceCache) error
	InitializeTaskCache(int, string, string) error
	ContainerHandle() string
	ParentHandle() string
	ResourceType() (*VolumeResourceType, error)
	BaseResourceType() (*UsedWorkerBaseResourceType, error)
	TaskIdentifier() (string, string, string, error)
}

type CreatingContainer 

type CreatingContainer interface {
	Container

	Created() (CreatedContainer, error)
}

type CreatingVolume 

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

type Dashboard 

type Dashboard []DashboardJob

type DashboardJob 

type DashboardJob struct {
	Job Job

	FinishedBuild Build
	NextBuild     Build
}

type DestroyingContainer 

type DestroyingContainer interface {
	Container

	Destroy() (bool, error)
	IsDiscontinued() bool
}

type DestroyingVolume 

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

type EncryptionKey 

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

func NewEncryptionKey 

func NewEncryptionKey(a cipher.AEAD) *EncryptionKey

func (EncryptionKey) Decrypt 

func (e EncryptionKey) Decrypt(text string, n *string) ([]byte, error)

func (EncryptionKey) Encrypt 

func (e EncryptionKey) Encrypt(plaintext []byte) (string, *string, error)

type EncryptionStrategy 

type EncryptionStrategy interface {
	Encrypt([]byte) (string, *string, error)
	Decrypt(string, *string) ([]byte, error)
}

type ErrCustomResourceTypeVersionNotFound 

type ErrCustomResourceTypeVersionNotFound struct {
	Name string
}

func (ErrCustomResourceTypeVersionNotFound) Error 

func (e ErrCustomResourceTypeVersionNotFound) Error() string

type ErrResourceNotFound 

type ErrResourceNotFound struct {
	Name string
}

func (ErrResourceNotFound) Error 

func (e ErrResourceNotFound) Error() string

type ErrVolumeMarkCreatedFailed 

type ErrVolumeMarkCreatedFailed struct {
	Handle string
}

func (ErrVolumeMarkCreatedFailed) Error 

func (e ErrVolumeMarkCreatedFailed) Error() string

type EventSource 

type EventSource interface {
	Next() (event.Envelope, error)
	Close() error
}

type FirstLoggedBuildIDDecreasedError 

type FirstLoggedBuildIDDecreasedError struct {
	Job   string
	OldID int
	NewID int
}

func (FirstLoggedBuildIDDecreasedError) Error 

func (e FirstLoggedBuildIDDecreasedError) Error() string

type Job 

type Job interface {
	ID() int
	Name() string
	Paused() bool
	FirstLoggedBuildID() int
	PipelineID() int
	PipelineName() string
	TeamID() int
	TeamName() string
	Config() atc.JobConfig

	Reload() (bool, error)

	Pause() error
	Unpause() error

	CreateBuild() (Build, error)
	Builds(page Page) ([]Build, Pagination, error)
	Build(name string) (Build, bool, error)
	FinishedAndNextBuild() (Build, Build, error)
	UpdateFirstLoggedBuildID(newFirstLoggedBuildID int) error
	EnsurePendingBuildExists() error
	GetPendingBuilds() ([]Build, error)

	GetIndependentBuildInputs() ([]BuildInput, error)
	GetNextBuildInputs() ([]BuildInput, bool, error)
	SaveNextInputMapping(inputMapping algorithm.InputMapping) error
	SaveIndependentInputMapping(inputMapping algorithm.InputMapping) error
	DeleteNextInputMapping() error

	SetMaxInFlightReached(bool) error
	GetRunningBuildsBySerialGroup(serialGroups []string) ([]Build, error)
	GetNextPendingBuildBySerialGroup(serialGroups []string) (Build, bool, error)
}

type Jobs 

type Jobs []Job

func (Jobs) Configs 

func (jobs Jobs) Configs() atc.JobConfigs

type MissingInputReasons 

type MissingInputReasons map[string]string

func (MissingInputReasons) RegisterNoVersions 

func (mir MissingInputReasons) RegisterNoVersions(inputName string)

func (MissingInputReasons) RegisterPassedConstraint 

func (mir MissingInputReasons) RegisterPassedConstraint(inputName string)

func (MissingInputReasons) RegisterPinnedVersionUnavailable 

func (mir MissingInputReasons) RegisterPinnedVersionUnavailable(inputName string, version string)

type NoEncryption 

type NoEncryption struct{}

func NewNoEncryption 

func NewNoEncryption() *NoEncryption

func (NoEncryption) Decrypt 

func (n NoEncryption) Decrypt(text string, nonce *string) ([]byte, error)

func (NoEncryption) Encrypt 

func (n NoEncryption) Encrypt(plaintext []byte) (string, *string, error)

type NotificationsBus 

type NotificationsBus interface {
	Listen(channel string) (chan bool, error)
	Notify(channel string) error
	Unlisten(channel string, notify chan bool) error
	Close() error
}

type Notifier 

type Notifier interface {
	Notify() <-chan struct{}
	Close() error
}

type Page 

type Page struct {
	Since int // exclusive
	Until int // exclusive

	From int // inclusive
	To   int // inclusive

	Limit int
}

type Pagination 

type Pagination struct {
	Previous *Page
	Next     *Page
}

type Pipe 

type Pipe struct {
	ID       string
	URL      string
	TeamName string
}

type Pipeline 

type Pipeline interface {
	ID() int
	Name() string
	TeamID() int
	TeamName() string
	Groups() atc.GroupConfigs
	ConfigVersion() ConfigVersion
	Public() bool
	Paused() bool
	ScopedName(string) string

	CheckPaused() (bool, error)
	Reload() (bool, error)

	SetResourceCheckError(Resource, error) error
	SaveResourceVersions(atc.ResourceConfig, []atc.Version) error
	GetResourceVersions(resourceName string, page Page) ([]SavedVersionedResource, Pagination, bool, error)

	GetAllPendingBuilds() (map[string][]Build, error)

	GetLatestVersionedResource(resourceName string) (SavedVersionedResource, bool, error)
	GetVersionedResourceByVersion(atcVersion atc.Version, resourceName string) (SavedVersionedResource, bool, error)

	DisableVersionedResource(versionedResourceID int) error
	EnableVersionedResource(versionedResourceID int) error
	GetBuildsWithVersionAsInput(versionedResourceID int) ([]Build, error)
	GetBuildsWithVersionAsOutput(versionedResourceID int) ([]Build, error)

	DeleteBuildEventsByBuildIDs(buildIDs []int) error

	// Needs test (from db/lock_test.go)
	AcquireSchedulingLock(lager.Logger, time.Duration) (lock.Lock, bool, error)

	AcquireResourceCheckingLockWithIntervalCheck(
		logger lager.Logger,
		resourceName string,
		usedResourceConfig *UsedResourceConfig,
		interval time.Duration,
		immediate bool,
	) (lock.Lock, bool, error)

	AcquireResourceTypeCheckingLockWithIntervalCheck(
		logger lager.Logger,
		resourceTypeName string,
		usedResourceConfig *UsedResourceConfig,
		interval time.Duration,
		immediate bool,
	) (lock.Lock, bool, error)

	LoadVersionsDB() (*algorithm.VersionsDB, error)

	Resource(name string) (Resource, bool, error)
	Resources() (Resources, error)

	ResourceTypes() (ResourceTypes, error)
	ResourceType(name string) (ResourceType, bool, error)

	Job(name string) (Job, bool, error)
	Jobs() (Jobs, error)
	Dashboard() (Dashboard, atc.GroupConfigs, error)

	Expose() error
	Hide() error

	Pause() error
	Unpause() error

	Destroy() error
	Rename(string) error

	CreateOneOffBuild() (Build, error)
}

type PipelineFactory 

type PipelineFactory interface {
	PublicPipelines() ([]Pipeline, error)
	AllPipelines() ([]Pipeline, error)
}

func NewPipelineFactory 

func NewPipelineFactory(conn Conn, lockFactory lock.LockFactory) PipelineFactory

type PipelinePausedState 

type PipelinePausedState string
const (
	PipelinePaused   PipelinePausedState = "paused"
	PipelineUnpaused PipelinePausedState = "unpaused"
	PipelineNoChange PipelinePausedState = "nochange"
)

func (PipelinePausedState) Bool 

func (state PipelinePausedState) Bool() *bool

type Resource 

type Resource interface {
	ID() int
	Name() string
	PipelineName() string
	Type() string
	Source() atc.Source
	CheckEvery() string
	Tags() atc.Tags
	CheckError() error
	Paused() bool
	WebhookToken() string
	FailingToCheck() bool

	Pause() error
	Unpause() error

	Reload() (bool, error)
}

type ResourceCache 

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.
}

ResourceCache represents an instance of a ResourceConfig's version.

A ResourceCache is created by a `get`, an `image_resource`, or a resource type in a pipeline.

ResourceCaches are garbage-collected by gc.ResourceCacheCollector.

func (ResourceCache) Find 

func (cache ResourceCache) Find(tx Tx) (*UsedResourceCache, bool, error)

type ResourceCacheFactory 

type ResourceCacheFactory interface {
	FindOrCreateResourceCache(
		logger lager.Logger,
		resourceUser ResourceUser,
		resourceTypeName string,
		version atc.Version,
		source atc.Source,
		params atc.Params,
		resourceTypes creds.VersionedResourceTypes,
	) (*UsedResourceCache, error)

	CleanUsesForFinishedBuilds() error
	CleanUsesForInactiveResourceTypes() error
	CleanUsesForInactiveResources() error
	CleanUsesForPausedPipelineResources() error
	CleanBuildImageResourceCaches() error
	CleanUpInvalidCaches() error

	// changing resource cache to interface to allow updates on object is not feasible.
	// Since we need to pass it recursively in UsedResourceConfig.
	// Also, metadata will be available to us before we create resource cache so this
	// method can be removed at that point. See  https://github.com/concourse/concourse/issues/534
	UpdateResourceCacheMetadata(*UsedResourceCache, []atc.MetadataField) error
	ResourceCacheMetadata(*UsedResourceCache) (ResourceMetadataFields, error)
}

func NewResourceCacheFactory 

func NewResourceCacheFactory(conn Conn) ResourceCacheFactory

type ResourceConfig 

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
}

ResourceConfig represents a resource type and config source.

Resources in a pipeline, resource types in a pipeline, and `image_resource` fields in a task all result in a reference to a ResourceConfig.

ResourceConfigs are garbage-collected by gc.ResourceConfigCollector.

func (ResourceConfig) Find 

func (resourceConfig ResourceConfig) Find(tx Tx) (*UsedResourceConfig, bool, error)

type ResourceConfigCheckSessionLifecycle 

type ResourceConfigCheckSessionLifecycle interface {
	CleanExpiredResourceConfigCheckSessions() error
}

func NewResourceConfigCheckSessionLifecycle 

func NewResourceConfigCheckSessionLifecycle(conn Conn) ResourceConfigCheckSessionLifecycle

type ResourceConfigFactory 

type ResourceConfigFactory interface {
	FindOrCreateResourceConfig(
		logger lager.Logger,
		user ResourceUser,
		resourceType string,
		source atc.Source,
		resourceTypes creds.VersionedResourceTypes,
	) (*UsedResourceConfig, error)

	FindResourceConfig(
		logger lager.Logger,
		resourceType string,
		source atc.Source,
		resourceTypes creds.VersionedResourceTypes,
	) (*UsedResourceConfig, bool, error)

	CleanConfigUsesForFinishedBuilds() error
	CleanConfigUsesForInactiveResourceTypes() error
	CleanConfigUsesForInactiveResources() error
	CleanConfigUsesForPausedPipelinesResources() error
	CleanConfigUsesForOutdatedResourceConfigs() error
	CleanUselessConfigs() error

	AcquireResourceCheckingLock(
		logger lager.Logger,
		resourceUser ResourceUser,
		resourceType string,
		resourceSource atc.Source,
		resourceTypes creds.VersionedResourceTypes,
	) (lock.Lock, bool, error)
}

func NewResourceConfigFactory 

func NewResourceConfigFactory(conn Conn, lockFactory lock.LockFactory) ResourceConfigFactory

type ResourceMetadataField 

type ResourceMetadataField struct {
	Name  string
	Value string
}

type ResourceMetadataFields 

type ResourceMetadataFields []ResourceMetadataField

func NewResourceMetadataFields 

func NewResourceMetadataFields(atcm []atc.MetadataField) ResourceMetadataFields

func (ResourceMetadataFields) ToATCMetadata 

func (rmf ResourceMetadataFields) ToATCMetadata() []atc.MetadataField

type ResourceNotFoundError 

type ResourceNotFoundError struct {
	Name string
}

func (ResourceNotFoundError) Error 

func (e ResourceNotFoundError) Error() string

type ResourceType 

type ResourceType interface {
	ID() int
	Name() string
	Type() string
	Privileged() bool
	Source() atc.Source

	Version() atc.Version
	SaveVersion(atc.Version) error

	Reload() (bool, error)
}

type ResourceTypeNotFoundError 

type ResourceTypeNotFoundError struct {
	Name string
}

func (ResourceTypeNotFoundError) Error 

func (e ResourceTypeNotFoundError) Error() string

type ResourceTypes 

type ResourceTypes []ResourceType

func (ResourceTypes) Configs 

func (resourceTypes ResourceTypes) Configs() atc.ResourceTypes

func (ResourceTypes) Deserialize 

func (resourceTypes ResourceTypes) Deserialize() atc.VersionedResourceTypes

type ResourceUser 

type ResourceUser interface {
	UseResourceCache(lager.Logger, Tx, ResourceCache) (*UsedResourceCache, error)
	UseResourceConfig(lager.Logger, Tx, ResourceConfig) (*UsedResourceConfig, error)

	Description() string
}

ResourceUser encapsulates the ownership of a resource cache or config, by managing the resource_config_users and resource_cache_users tables.

These tables exist because resource caches and resource configs outlive most objects that reference them. They are referenced by multiple objects, and should only be garbage collectible when all uses go away. A simpler model of this would be simply incrementing/decrementing a 'uses' column on the cache or config itself, and garbage-collecting it if it's zero. However, this would not allow us to tell when a use is no longer needed, as they wouldn't be tied to who needed them. Having a separate 'uses' table allows us to know when a use is no longer valid, e.g. because it's a build that completed or a resource that is no longer being checked.

func ForBuild 

func ForBuild(id int) ResourceUser

func ForResource 

func ForResource(id int) ResourceUser

func ForResourceType 

func ForResourceType(id int) ResourceUser

type ResourceVersion 

type ResourceVersion map[string]string

type Resources 

type Resources []Resource

func (Resources) Configs 

func (resources Resources) Configs() atc.ResourceConfigs

func (Resources) Lookup 

func (resources Resources) Lookup(name string) (Resource, bool)

type SavedVersionedResource 

type SavedVersionedResource struct {
	ID           int
	Enabled      bool
	ModifiedTime time.Time
	VersionedResource
	CheckOrder int
}

type SavedVersionedResources 

type SavedVersionedResources []SavedVersionedResource

type Team 

type Team interface {
	ID() int
	Name() string
	Admin() bool

	BasicAuth() *atc.BasicAuth
	Auth() map[string]*json.RawMessage

	Delete() error

	SavePipeline(
		pipelineName string,
		config atc.Config,
		from ConfigVersion,
		pausedState PipelinePausedState,
	) (Pipeline, bool, error)

	Pipeline(pipelineName string) (Pipeline, bool, error)
	Pipelines() ([]Pipeline, error)
	PublicPipelines() ([]Pipeline, error)
	VisiblePipelines() ([]Pipeline, error)
	OrderPipelines([]string) error

	CreateOneOffBuild() (Build, error)
	PrivateAndPublicBuilds(Page) ([]Build, Pagination, error)

	SaveWorker(atcWorker atc.Worker, ttl time.Duration) (Worker, error)
	Workers() ([]Worker, error)

	FindContainerByHandle(string) (Container, bool, error)
	FindContainersByMetadata(ContainerMetadata) ([]Container, error)
	FindCheckContainers(lager.Logger, string, string, creds.VariablesFactory) ([]Container, error)

	FindCreatedContainerByHandle(string) (CreatedContainer, bool, error)

	FindWorkerForContainer(handle string) (Worker, bool, error)

	FindWorkerForContainerByOwner(ContainerOwner) (Worker, bool, error)
	FindContainerOnWorker(workerName string, owner ContainerOwner) (CreatingContainer, CreatedContainer, error)
	CreateContainer(workerName string, owner ContainerOwner, meta ContainerMetadata) (CreatingContainer, error)

	UpdateBasicAuth(basicAuth *atc.BasicAuth) error
	UpdateProviderAuth(auth map[string]*json.RawMessage) error

	CreatePipe(string, string) error
	GetPipe(string) (Pipe, error)
}

type TeamFactory 

type TeamFactory interface {
	CreateTeam(atc.Team) (Team, error)
	FindTeam(string) (Team, bool, error)
	GetTeams() ([]Team, error)
	GetByID(teamID int) Team
	CreateDefaultTeamIfNotExists() (Team, error)
}

func NewTeamFactory 

func NewTeamFactory(conn Conn, lockFactory lock.LockFactory) TeamFactory

type Tx 

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{}) squirrel.RowScanner
	Rollback() error
	Stmt(stmt *sql.Stmt) *sql.Stmt
}

type UsedBaseResourceType 

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

UsedBaseResourceType is created whenever a ResourceConfig is used, either for a build, a resource in the pipeline, or a resource type in the pipeline.

So long as the UsedBaseResourceType's ID is referenced by a ResourceConfig that is in use, this guarantees that the BaseResourceType will not be removed. That is to say that its "Use" is vicarious.

type UsedResourceCache 

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

UsedResourceCache is created whenever a ResourceCache is Created and/or Used.

So long as the UsedResourceCache exists, the underlying ResourceCache can not be removed.

UsedResourceCaches become unused by the gc.ResourceCacheCollector, which may then lead to the ResourceCache being garbage-collected.

See FindOrCreateForBuild, FindOrCreateForResource, and FindOrCreateForResourceType for more information on when it becomes unused.

func (*UsedResourceCache) BaseResourceType 

func (usedResourceCache *UsedResourceCache) BaseResourceType() *UsedBaseResourceType

func (*UsedResourceCache) Destroy 

func (cache *UsedResourceCache) Destroy(tx Tx) (bool, error)

type UsedResourceConfig 

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

UsedResourceConfig is created whenever a ResourceConfig is Created and/or Used.

So long as the UsedResourceConfig exists, the underlying ResourceConfig can not be removed.

UsedResourceConfigs become unused by the gc.ResourceConfigCollector, which may then lead to the ResourceConfig being garbage-collected.

See FindOrCreateForBuild, FindOrCreateForResource, and FindOrCreateForResourceType for more information on when it becomes unused.

func (*UsedResourceConfig) OriginBaseResourceType 

func (resourceConfig *UsedResourceConfig) OriginBaseResourceType() *UsedBaseResourceType

type UsedWorkerBaseResourceType 

type UsedWorkerBaseResourceType struct {
	ID      int
	Name    string
	Version string

	WorkerName string
}

type UsedWorkerResourceCache 

type UsedWorkerResourceCache struct {
	ID int
}

type UsedWorkerResourceType 

type UsedWorkerResourceType struct {
	ID int

	Worker Worker

	UsedBaseResourceType *UsedBaseResourceType
}

type UsedWorkerTaskCache 

type UsedWorkerTaskCache struct {
	ID         int
	WorkerName string
}

type UserDisappearedError 

type UserDisappearedError struct {
	User ResourceUser
}

func (UserDisappearedError) Error 

func (err UserDisappearedError) Error() string

type VersionedResource 

type VersionedResource struct {
	Resource string
	Type     string
	Version  ResourceVersion
	Metadata ResourceMetadataFields
}

type VolumeFactory 

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

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

	FindBaseResourceTypeVolume(int, *UsedWorkerBaseResourceType) (CreatingVolume, CreatedVolume, error)
	CreateBaseResourceTypeVolume(int, *UsedWorkerBaseResourceType) (CreatingVolume, error)

	FindResourceCacheVolume(string, *UsedResourceCache) (CreatedVolume, bool, error)

	FindTaskCacheVolume(teamID int, uwtc *UsedWorkerTaskCache) (CreatingVolume, CreatedVolume, error)
	CreateTaskCacheVolume(teamID int, uwtc *UsedWorkerTaskCache) (CreatingVolume, error)

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

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

func NewVolumeFactory 

func NewVolumeFactory(conn Conn) VolumeFactory

type VolumeResourceType 

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

type VolumeState 

type VolumeState string
const (
	VolumeStateCreating   VolumeState = "creating"
	VolumeStateCreated    VolumeState = "created"
	VolumeStateDestroying VolumeState = "destroying"
)

type VolumeType 

type VolumeType string
const (
	VolumeTypeContainer    VolumeType = "container"
	VolumeTypeResource     VolumeType = "resource"
	VolumeTypeResourceType VolumeType = "resource-type"
	VolumeTypeTaskCache    VolumeType = "task-cache"
	VolumeTypeUknown       VolumeType = "unknown" // for migration to life
)

type Worker 

type Worker interface {
	Name() string
	Version() *string
	State() WorkerState
	GardenAddr() *string
	BaggageclaimURL() *string
	HTTPProxyURL() string
	HTTPSProxyURL() string
	NoProxy() string
	ActiveContainers() int
	ResourceTypes() []atc.WorkerResourceType
	Platform() string
	Tags() []string
	TeamID() int
	TeamName() string
	StartTime() int64
	ExpiresAt() time.Time

	Reload() (bool, error)

	Land() error
	Retire() error
	Prune() error
	Delete() error
}

type WorkerBaseResourceType 

type WorkerBaseResourceType struct {
	Name       string
	WorkerName string
}

func (WorkerBaseResourceType) Find 

func (workerBaseResourceType WorkerBaseResourceType) Find(runner sq.Runner) (*UsedWorkerBaseResourceType, bool, error)

type WorkerBaseResourceTypeAlreadyExistsError 

type WorkerBaseResourceTypeAlreadyExistsError struct {
	WorkerName           string
	BaseResourceTypeName string
}

func (WorkerBaseResourceTypeAlreadyExistsError) Error 

func (e WorkerBaseResourceTypeAlreadyExistsError) Error() string

type WorkerBaseResourceTypeFactory 

type WorkerBaseResourceTypeFactory interface {
	Find(name string, worker Worker) (*UsedWorkerBaseResourceType, bool, error)
}

func NewWorkerBaseResourceTypeFactory 

func NewWorkerBaseResourceTypeFactory(conn Conn) WorkerBaseResourceTypeFactory

type WorkerFactory 

type WorkerFactory interface {
	GetWorker(name string) (Worker, bool, error)
	SaveWorker(atcWorker atc.Worker, ttl time.Duration) (Worker, error)
	HeartbeatWorker(worker atc.Worker, ttl time.Duration) (Worker, error)
	Workers() ([]Worker, error)
}

func NewWorkerFactory 

func NewWorkerFactory(conn Conn) WorkerFactory

type WorkerLifecycle 

type WorkerLifecycle interface {
	StallUnresponsiveWorkers() ([]string, error)
	LandFinishedLandingWorkers() ([]string, error)
	DeleteFinishedRetiringWorkers() ([]string, error)
}

func NewWorkerLifecycle 

func NewWorkerLifecycle(conn Conn) WorkerLifecycle

type WorkerResourceCache 

type WorkerResourceCache struct {
	WorkerName    string
	ResourceCache *UsedResourceCache
}

func (WorkerResourceCache) Find 

func (workerResourceCache WorkerResourceCache) Find(runner sq.Runner) (*UsedWorkerResourceCache, bool, error)

func (WorkerResourceCache) FindOrCreate 

func (workerResourceCache WorkerResourceCache) FindOrCreate(tx Tx) (*UsedWorkerResourceCache, error)

type WorkerResourceType 

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
}

func (WorkerResourceType) FindOrCreate 

func (wrt WorkerResourceType) FindOrCreate(tx Tx) (*UsedWorkerResourceType, error)

type WorkerState 

type WorkerState string

type WorkerTaskCache 

type WorkerTaskCache struct {
	JobID      int
	StepName   string
	WorkerName string
	Path       string
}

func (WorkerTaskCache) FindOrCreate 

func (wtc WorkerTaskCache) FindOrCreate(
	tx Tx,
) (*UsedWorkerTaskCache, error)

type WorkerTaskCacheFactory 

type WorkerTaskCacheFactory interface {
	Find(jobID int, stepName string, path string, workerName string) (*UsedWorkerTaskCache, bool, error)
	FindOrCreate(jobID int, stepName string, path string, workerName string) (*UsedWorkerTaskCache, error)
}

func NewWorkerTaskCacheFactory 

func NewWorkerTaskCacheFactory(conn Conn) WorkerTaskCacheFactory

Source Files

View all Source files

Directories

Path Synopsis
Code generated by counterfeiter.
 Code generated by counterfeiter.
lockfakes
Code generated by counterfeiter.
 Code generated by counterfeiter.
internal/163
internal/26
migrationsfakes
Code generated by counterfeiter.
 Code generated by counterfeiter.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.