groot

Documentation

Index

• Constants
• func IamCleaner(locksmith Locksmith, sm StoreMeasurer, gc GarbageCollector, ...) *cleaner
• type BaseImage
• type BaseImagePuller
• type BaseImageSpec
• type Cleaner
• type CreateSpec
• type Creator
  • func IamCreator(imageCloner ImageCloner, baseImagePuller BaseImagePuller, locksmith Locksmith, ...) *Creator
  • func (c *Creator) Create(logger lager.Logger, spec CreateSpec) (ImageInfo, error)
• type Deleter
  • func IamDeleter(imageCloner ImageCloner, dependencyManager DependencyManager, ...) *Deleter
  • func (d *Deleter) Delete(logger lager.Logger, id string) error
• type DependencyManager
• type DiskUsage
• type GarbageCollector
• type IDMappingSpec
• type ImageCloner
• type ImageInfo
• type ImageSpec
• type Lister
  • func IamLister() *Lister
  • func (l *Lister) List(logger lager.Logger, storePath string) ([]string, error)
• type Locksmith
• type MetricsEmitter
• type MountInfo
• type NamespaceChecker
• type RootFSConfigurer
• type Statser
  • func IamStatser(imageCloner ImageCloner, metricsEmitter MetricsEmitter) *Statser
  • func (m *Statser) Stats(logger lager.Logger, id string) (VolumeStats, error)
• type StoreMeasurer
• type StoreNamespacer
  • func NewStoreNamespacer(storePath string) *StoreNamespacer
  • func (n *StoreNamespacer) Check(uidMappings, gidMappings []IDMappingSpec) (bool, error)
  • func (n *StoreNamespacer) Write(storePath string, uidMappings, gidMappings []IDMappingSpec) error
• type VolumeStats

Constants

const (
	GlobalLockKey           = "global-groot-lock"
	MetricImageCreationTime = "ImageCreationTime"
	MetricImageDeletionTime = "ImageDeletionTime"
	MetricImageStatsTime    = "ImageStatsTime"
	MetricImageCleanTime    = "ImageCleanTime"
)

const ImageReferenceFormat = "image:%s"

const NamespaceFilename = "namespace.json"

Functions

func IamCleaner

func IamCleaner(locksmith Locksmith, sm StoreMeasurer,
	gc GarbageCollector, metricsEmitter MetricsEmitter,
) *cleaner

Types

type BaseImage

type BaseImage struct {
	VolumePath string
	BaseImage  specsv1.Image
	ChainIDs   []string
}

type BaseImagePuller

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

type BaseImageSpec

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

type Cleaner

type Cleaner interface {
	Clean(logger lager.Logger, threshold int64, keepImages []string, acquireLock bool) (bool, error)
}

type CreateSpec

type CreateSpec struct {
	ID                          string
	BaseImage                   string
	DiskLimit                   int64
	Json                        bool
	Mount                       bool
	ExcludeBaseImageFromQuota   bool
	CleanOnCreate               bool
	CleanOnCreateThresholdBytes int64
	CleanOnCreateIgnoreImages   []string
	UIDMappings                 []IDMappingSpec
	GIDMappings                 []IDMappingSpec
}

type Creator

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

func IamCreator

func IamCreator(
	imageCloner ImageCloner, baseImagePuller BaseImagePuller,
	locksmith Locksmith, rootFSConfigurer RootFSConfigurer,
	dependencyManager DependencyManager, metricsEmitter MetricsEmitter, cleaner Cleaner,
	namespaceChecker NamespaceChecker) *Creator

func (*Creator) Create

func (c *Creator) Create(logger lager.Logger, spec CreateSpec) (ImageInfo, error)

type Deleter

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

func IamDeleter

func IamDeleter(imageCloner ImageCloner, dependencyManager DependencyManager, metricsEmitter MetricsEmitter) *Deleter

func (*Deleter) Delete

func (d *Deleter) Delete(logger lager.Logger, id string) error

type DependencyManager

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

type DiskUsage

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

type GarbageCollector

type GarbageCollector interface {
	Collect(logger lager.Logger, keepBaseImages []string) error
}

type IDMappingSpec

type IDMappingSpec struct {
	HostID      int
	NamespaceID int
	Size        int
}

type ImageCloner

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

type ImageInfo struct {
	Rootfs string         `json:"rootfs"`
	Config *specsv1.Image `json:"config,omitempty"`
	Mount  *MountInfo     `json:"mount,omitempty"`
	Path   string         `json:"-"`
}

type ImageSpec

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

type Lister

type Lister struct {
}

func IamLister

func IamLister() *Lister

func (*Lister) List

func (l *Lister) List(logger lager.Logger, storePath string) ([]string, error)

type Locksmith

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

type MetricsEmitter

type MetricsEmitter interface {
	TryEmitDuration(logger lager.Logger, name string, duration time.Duration)
}

type MountInfo

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

type NamespaceChecker

type NamespaceChecker interface {
	Check(uidMappings, gidMappings []IDMappingSpec) (bool, error)
}

type RootFSConfigurer

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

type Statser

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

func IamStatser

func IamStatser(imageCloner ImageCloner, metricsEmitter MetricsEmitter) *Statser

func (*Statser) Stats

func (m *Statser) Stats(logger lager.Logger, id string) (VolumeStats, error)

type StoreMeasurer

type StoreMeasurer interface {
	MeasureStore(logger lager.Logger) (int64, error)
}

type StoreNamespacer

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

func NewStoreNamespacer

func NewStoreNamespacer(storePath string) *StoreNamespacer

func (*StoreNamespacer) Check

func (n *StoreNamespacer) Check(uidMappings, gidMappings []IDMappingSpec) (bool, error)

func (*StoreNamespacer) Write

func (n *StoreNamespacer) Write(storePath string, uidMappings, gidMappings []IDMappingSpec) error

type VolumeStats

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