resource

Documentation

Index

• Constants
• Variables
• func GenerateResourceHash(source atc.Source, resourceType string) string
• func ResourcesDir(suffix string) string
• type Cache
• type EmptyMetadata
  • func (m EmptyMetadata) Env() []string
• type ErrResourceScriptFailed
  • func (err ErrResourceScriptFailed) Error() string
• type FetchSource
  • func NewContainerFetchSource(logger lager.Logger, container worker.Container, volume worker.Volume, ...) FetchSource
  • func NewResourceInstanceFetchSource(logger lager.Logger, resourceInstance ResourceInstance, worker worker.Worker, ...) FetchSource
• type FetchSourceProvider
• type FetchSourceProviderFactory
  • func NewFetchSourceProviderFactory(workerClient worker.Client) FetchSourceProviderFactory
• type Fetcher
  • func NewFetcher(clock clock.Clock, db LockDB, ...) Fetcher
• type FetcherFactory
  • func NewFetcherFactory(db LockDB, clock clock.Clock) FetcherFactory
• type IOConfig
• type LockDB
• type Metadata
• type Resource
  • func NewResourceForContainer(container worker.Container) Resource
• type ResourceFactory
• type ResourceFactoryFactory
  • func NewResourceFactoryFactory() ResourceFactoryFactory
• type ResourceInstance
  • func NewResourceInstance(resourceTypeName ResourceType, version atc.Version, source atc.Source, ...) ResourceInstance
• type ResourceOptions
• type ResourceType
• type Session
• type TrackerMetadata
  • func (m TrackerMetadata) Env() []string
• type VersionedSource
  • func NewGetVersionedSource(volume worker.Volume, version atc.Version, metadata []atc.MetadataField) VersionedSource

Constants

const GetResourceLockInterval = 5 * time.Second

Variables

var ErrAborted = errors.New("script aborted")

var ErrFailedToGetLock = errors.New("failed-to-get-lock")

var ErrInterrupted = errors.New("interrupted")

Functions

func GenerateResourceHash

func GenerateResourceHash(source atc.Source, resourceType string) string

func ResourcesDir

func ResourcesDir(suffix string) string

TODO: check if we need it

Types

type Cache

type Cache interface {
	IsInitialized() (bool, error)
	Initialize() error
	Volume() worker.Volume
}

type EmptyMetadata

type EmptyMetadata struct{}

func (EmptyMetadata) Env

func (m EmptyMetadata) Env() []string

type ErrResourceScriptFailed

type ErrResourceScriptFailed struct {
	Path       string
	Args       []string
	ExitStatus int

	Stderr string
}

func (ErrResourceScriptFailed) Error

func (err ErrResourceScriptFailed) Error() string

type FetchSource

type FetchSource interface {
	IsInitialized() (bool, error)
	LockName() (string, error)
	VersionedSource() VersionedSource
	Initialize(signals <-chan os.Signal, ready chan<- struct{}) error
}

func NewContainerFetchSource

func NewContainerFetchSource(
	logger lager.Logger,
	container worker.Container,
	volume worker.Volume,
	resourceOptions ResourceOptions,
) FetchSource

func NewResourceInstanceFetchSource

func NewResourceInstanceFetchSource(
	logger lager.Logger,
	resourceInstance ResourceInstance,
	worker worker.Worker,
	resourceOptions ResourceOptions,
	resourceTypes atc.VersionedResourceTypes,
	tags atc.Tags,
	teamID int,
	session Session,
	metadata Metadata,
	imageFetchingDelegate worker.ImageFetchingDelegate,
) FetchSource

type FetchSourceProvider

type FetchSourceProvider interface {
	Get() (FetchSource, error)
}

type FetchSourceProviderFactory

type FetchSourceProviderFactory interface {
	NewFetchSourceProvider(
		logger lager.Logger,
		session Session,
		metadata Metadata,
		tags atc.Tags,
		teamID int,
		resourceTypes atc.VersionedResourceTypes,
		resourceInstance ResourceInstance,
		resourceOptions ResourceOptions,
		imageFetchingDelegate worker.ImageFetchingDelegate,
	) FetchSourceProvider
}

func NewFetchSourceProviderFactory

func NewFetchSourceProviderFactory(workerClient worker.Client) FetchSourceProviderFactory

type Fetcher

type Fetcher interface {
	Fetch(
		logger lager.Logger,
		session Session,
		tags atc.Tags,
		teamID int,
		resourceTypes atc.VersionedResourceTypes,
		resourceInstance ResourceInstance,
		metadata Metadata,
		imageFetchingDelegate worker.ImageFetchingDelegate,
		resourceOptions ResourceOptions,
		signals <-chan os.Signal,
		ready chan<- struct{},
	) (FetchSource, error)
}

func NewFetcher

func NewFetcher(
	clock clock.Clock,
	db LockDB,
	fetchSourceProviderFactory FetchSourceProviderFactory,
) Fetcher

type FetcherFactory

type FetcherFactory interface {
	FetcherFor(workerClient worker.Client) Fetcher
}

func NewFetcherFactory

func NewFetcherFactory(
	db LockDB,
	clock clock.Clock,
) FetcherFactory

type IOConfig

type IOConfig struct {
	Stdout io.Writer
	Stderr io.Writer
}

type LockDB

type LockDB interface {
	GetTaskLock(logger lager.Logger, lockName string) (lock.Lock, bool, error)
}

type Metadata

type Metadata interface {
	Env() []string
}

type Resource

type Resource interface {
	Get(worker.Volume, IOConfig, atc.Source, atc.Params, atc.Version, <-chan os.Signal, chan<- struct{}) (VersionedSource, error)
	Put(IOConfig, atc.Source, atc.Params, <-chan os.Signal, chan<- struct{}) (VersionedSource, error)
	Check(atc.Source, atc.Version) ([]atc.Version, error)
	Container() worker.Container
}

func NewResourceForContainer

func NewResourceForContainer(container worker.Container) Resource

type ResourceFactory

type ResourceFactory interface {
	NewPutResource(
		logger lager.Logger,
		signals <-chan os.Signal,
		buildID int,
		planID atc.PlanID,
		metadata dbng.ContainerMetadata,
		containerSpec worker.ContainerSpec,
		resourceTypes atc.VersionedResourceTypes,
		imageFetchingDelegate worker.ImageFetchingDelegate,
	) (Resource, error)

	NewCheckResource(
		logger lager.Logger,
		signals <-chan os.Signal,
		resourceUser dbng.ResourceUser,
		resourceType string,
		resourceSource atc.Source,
		metadata dbng.ContainerMetadata,
		resourceSpec worker.ContainerSpec,
		resourceTypes atc.VersionedResourceTypes,
		imageFetchingDelegate worker.ImageFetchingDelegate,
	) (Resource, error)
}

type ResourceFactoryFactory

type ResourceFactoryFactory interface {
	FactoryFor(workerClient worker.Client) ResourceFactory
}

func NewResourceFactoryFactory

func NewResourceFactoryFactory() ResourceFactoryFactory

type ResourceInstance

type ResourceInstance interface {
	ResourceUser() dbng.ResourceUser

	FindInitializedOn(lager.Logger, worker.Client) (worker.Volume, bool, error)
	CreateOn(lager.Logger, worker.Client) (worker.Volume, error)

	ResourceCacheIdentifier() worker.ResourceCacheIdentifier
}

func NewResourceInstance

func NewResourceInstance(
	resourceTypeName ResourceType,
	version atc.Version,
	source atc.Source,
	params atc.Params,
	resourceUser dbng.ResourceUser,
	resourceTypes atc.VersionedResourceTypes,
	dbResourceCacheFactory dbng.ResourceCacheFactory,
) ResourceInstance

type ResourceOptions

type ResourceOptions interface {
	IOConfig() IOConfig
	Source() atc.Source
	Params() atc.Params
	Version() atc.Version
	ResourceType() ResourceType
	LockName(workerName string) (string, error)
}

type ResourceType

type ResourceType string

type Session

type Session struct {
	Metadata dbng.ContainerMetadata
}

type TrackerMetadata

type TrackerMetadata struct {
	ExternalURL  string
	PipelineName string
	ResourceName string
}

func (TrackerMetadata) Env

func (m TrackerMetadata) Env() []string

type VersionedSource

type VersionedSource interface {
	Version() atc.Version
	Metadata() []atc.MetadataField

	StreamOut(string) (io.ReadCloser, error)
	StreamIn(string, io.Reader) error

	Volume() worker.Volume
}

func NewGetVersionedSource

func NewGetVersionedSource(volume worker.Volume, version atc.Version, metadata []atc.MetadataField) VersionedSource