groot

type BaseImageInfo struct {
	LayerInfos []LayerInfo
	Config     specsv1.Image
}

type BaseImagePuller interface {
	FetchBaseImageInfo(logger lager.Logger, spec BaseImageSpec) (BaseImageInfo, error)
	Pull(logger lager.Logger, imageInfo BaseImageInfo, spec BaseImageSpec) error
}

type BaseImageSpec struct {
	DiskLimit                 int64
	ExcludeBaseImageFromQuota bool
	BaseImageSrc              *url.URL
	UIDMappings               []IDMappingSpec
	GIDMappings               []IDMappingSpec
	OwnerUID                  int
	OwnerGID                  int
}

type Cleaner interface {
	Clean(logger lager.Logger, cacheSize int64, chainIDsToPreserve []string) (bool, error)
}

type CreateSpec struct {
	ID                          string
	BaseImageURL                *url.URL
	DiskLimit                   int64
	Mount                       bool
	ExcludeBaseImageFromQuota   bool
	CleanOnCreate               bool
	CleanOnCreateThresholdBytes int64
	UIDMappings                 []IDMappingSpec
	GIDMappings                 []IDMappingSpec
}

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

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

type DependencyManager interface {
	Register(id string, chainIDs []string) error
	Deregister(id string) error
}

type DiskUsage struct {
	TotalBytesUsed     int64 `json:"total_bytes_used"`
	ExclusiveBytesUsed int64 `json:"exclusive_bytes_used"`
}

type GarbageCollector interface {
	UnusedVolumes(logger lager.Logger, chainIDsToPreserve []string) ([]string, error)
	MarkUnused(logger lager.Logger, unusedVolumes []string) error
	Collect(logger lager.Logger) error
}

type IDMappingSpec struct {
	HostID      int
	NamespaceID int
	Size        int
}

type IDMappings struct {
	UIDMappings []IDMappingSpec
	GIDMappings []IDMappingSpec
}

type ImageCloner interface {
	Exists(id string) (bool, error)
	Create(logger lager.Logger, spec ImageSpec) (ImageInfo, error)
	Destroy(logger lager.Logger, id string) error
	Stats(logger lager.Logger, id string) (VolumeStats, error)
}

type ImageInfo struct {
	Rootfs string        `json:"rootfs"`
	Image  specsv1.Image `json:"image,omitempty"`
	Mounts []MountInfo   `json:"mounts,omitempty"`
	Path   string        `json:"-"`
}

type ImageSpec struct {
	ID                        string
	Mount                     bool
	DiskLimit                 int64
	ExcludeBaseImageFromQuota bool
	BaseVolumeIDs             []string
	BaseImage                 specsv1.Image
	OwnerUID                  int
	OwnerGID                  int
}

type LayerInfo struct {
	BlobID        string
	ChainID       string
	DiffID        string
	ParentChainID string
	Size          int64
	BaseDirectory string
	URLs          []string
	MediaType     string
}

type Lister struct {
}

type Locksmith interface {
	Lock(key string) (*os.File, error)
	Unlock(lockFile *os.File) error
}

type MetricsEmitter interface {
	TryEmitUsage(logger lager.Logger, name string, usage int64, units string)
	TryEmitDurationFrom(logger lager.Logger, name string, from time.Time)
}

type MountInfo struct {
	Destination string   `json:"destination"`
	Type        string   `json:"type"`
	Source      string   `json:"source"`
	Options     []string `json:"options"`
}

type RootFSConfigurer interface {
	Configure(rootFSPath string, baseImage *specsv1.Image) error
}

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

type StoreMeasurer interface {
	Usage(logger lager.Logger) (int64, error)
	CacheUsage(logger lager.Logger, volumes []string) int64
}

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

type VolumeStats struct {
	DiskUsage DiskUsage `json:"disk_usage"`
}