gcsx

package
v2.8.3 Latest Latest
Warning

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

Go to latest
Published: Mar 21, 2024 License: Apache-2.0 Imports: 32 Imported by: 0

Documentation

Index

Constants

View Source
const MB = 1 << 20

MB is 1 Megabyte. (Silly comment to make the lint warning go away)

View Source
const MtimeMetadataKey = "gcsfuse_mtime"

MtimeMetadataKey objects are created by Syncer.SyncObject and contain a metadata field with this key and with a UTC mtime in the format defined by time.RFC3339Nano.

View Source
const ReadOp = "readOp"

"readOp" is the value used in read context to store pointer to the read operation.

Variables

This section is empty.

Functions

func NewContentTypeBucket

func NewContentTypeBucket(b gcs.Bucket) gcs.Bucket

NewContentTypeBucket creates a wrapper bucket that guesses MIME types for newly created or composed objects when an explicit type is not already set.

func NewPrefixBucket

func NewPrefixBucket(
	prefix string,
	wrapped gcs.Bucket) (b gcs.Bucket, err error)

NewPrefixBucket creates a view on the wrapped bucket that pretends as if only the objects whose names contain the supplied string as a strict prefix exist, and that strips the prefix from the names of those objects before exposing them.

In order to preserve the invariant that object names are valid UTF-8, prefix must be valid UTF-8.

Types

type BucketConfig

type BucketConfig struct {
	BillingProject                     string
	OnlyDir                            string
	EgressBandwidthLimitBytesPerSecond float64
	OpRateLimitHz                      float64
	StatCacheMaxSizeMB                 uint64
	StatCacheTTL                       time.Duration
	EnableMonitoring                   bool
	DebugGCS                           bool

	// Files backed by on object of length at least AppendThreshold that have
	// only been appended to (i.e. none of the object's contents have been
	// dirtied) will be written out by "appending" to the object in GCS with this
	// process:
	//
	// 1. Write out a temporary object containing the appended contents whose
	//    name begins with TmpObjectPrefix.
	//
	// 2. Compose the original object and the temporary object on top of the
	//    original object.
	//
	// 3. Delete the temporary object.
	//
	// Note that if the process fails or is interrupted the temporary object will
	// not be cleaned up, so the user must ensure that TmpObjectPrefix is
	// periodically garbage collected.
	AppendThreshold int64
	TmpObjectPrefix string
}

type BucketManager

type BucketManager interface {
	SetUpBucket(
		ctx context.Context,
		name string, isMultibucketMount bool) (b SyncerBucket, err error)

	// Shuts down the bucket manager and its buckets
	ShutDown()
}

BucketManager manages the lifecycle of buckets.

func NewBucketManager

func NewBucketManager(config BucketConfig, storageHandle storage.StorageHandle) BucketManager

type RandomReader

type RandomReader interface {
	// Panic if any internal invariants are violated.
	CheckInvariants()

	// ReadAt Matches the semantics of io.ReaderAt, with the addition of context
	// support and cache support. It returns a boolean which represent either
	// content is read from fileCache (cacheHit = true) or gcs (cacheHit = false)
	ReadAt(ctx context.Context, p []byte, offset int64) (n int, cacheHit bool, err error)

	// Return the record for the object to which the reader is bound.
	Object() (o *gcs.MinObject)

	// Clean up any resources associated with the reader, which must not be used
	// again.
	Destroy()
}

RandomReader is an object that knows how to read ranges within a particular generation of a particular GCS object. Optimised for (large) sequential reads.

Not safe for concurrent access.

TODO - (raj-prince) - Rename this with appropriate name as it also started fulfilling the responsibility of reading object's content from cache.

func NewRandomReader

func NewRandomReader(o *gcs.MinObject, bucket gcs.Bucket, sequentialReadSizeMb int32, fileCacheHandler *file.CacheHandler, cacheFileForRangeRead bool) RandomReader

NewRandomReader create a random reader for the supplied object record that reads using the given bucket.

type StatResult

type StatResult struct {
	// The current size in bytes of the content.
	Size int64

	// The largest value T such that we are sure that the range of bytes [0, T)
	// is unmodified from the original content with which the temp file was
	// created.
	DirtyThreshold int64

	// The mtime of the temp file is updated according to the temp file's clock
	// with each call to a method that modified its content, and is also updated
	// when the user explicitly calls SetMtime.
	//
	// If neither of those things has ever happened, it is nil. This implies that
	// DirtyThreshold == Size.
	Mtime *time.Time
}

StatResult stores the result of a stat operation.

type Syncer

type Syncer interface {
	// Given an object record and content that was originally derived from that
	// object's contents (and potentially modified):
	//
	// *   If the temp file has not been modified, return a nil new object.
	//
	// *   Otherwise, write out a new generation in the bucket (failing with
	//     *gcs.PreconditionError if the source generation is no longer current).
	SyncObject(
		ctx context.Context,
		fileName string,
		srcObject *gcs.Object,
		content TempFile) (o *gcs.Object, err error)
}

Syncer is safe for concurrent access.

func NewSyncer

func NewSyncer(
	appendThreshold int64,
	tmpObjectPrefix string,
	bucket gcs.Bucket) (os Syncer)

NewSyncer creates a syncer that syncs into the supplied bucket.

When the source object has been changed only by appending, and the source object's size is at least appendThreshold, we will "append" to it by writing out a temporary blob and composing it with the source object.

Temporary blobs have names beginning with tmpObjectPrefix. We make an effort to delete them, but if we are interrupted for some reason we may not be able to do so. Therefore the user should arrange for garbage collection.

type SyncerBucket

type SyncerBucket struct {
	gcs.Bucket
	Syncer
}

func NewSyncerBucket

func NewSyncerBucket(
	appendThreshold int64,
	tmpObjectPrefix string,
	bucket gcs.Bucket,
) SyncerBucket

NewSyncerBucket creates a SyncerBucket, which can be used either as a gcs.Bucket, or as a Syncer.

type TempFile

type TempFile interface {
	// Panic if any internal invariants are violated.
	CheckInvariants()

	// Semantics matching os.File.
	io.ReadSeeker
	io.ReaderAt
	io.WriterAt
	Truncate(n int64) (err error)

	// Retrieve the file name
	Name() string

	// Return information about the current state of the content. May invalidate
	// the seek position.
	Stat() (sr StatResult, err error)

	// Explicitly set the mtime that will return in stat results. This will stick
	// until another method that modifies the file is called.
	SetMtime(mtime time.Time)

	// Throw away the resources used by the temporary file. The object must not
	// be used again.
	Destroy()
}

TempFile is a temporary file that keeps track of the lowest offset at which it has been modified.

Not safe for concurrent access.

func NewCacheFile

func NewCacheFile(
	source io.ReadCloser,
	f *os.File,
	dir string,
	clock timeutil.Clock) (tf TempFile)

NewCacheFile creates a wrapper temp file whose initial contents are given by the supplied source. dir is a directory on whose file system the file will live, or the system default temporary location if empty.

func NewTempFile

func NewTempFile(
	source io.ReadCloser,
	dir string,
	clock timeutil.Clock) (tf TempFile, err error)

NewTempFile creates a temp file whose initial contents are given by the supplied reader. dir is a directory on whose file system the inode will live, or the system default temporary location if empty.

func RecoverCacheFile

func RecoverCacheFile(
	source *os.File,
	dir string,
	clock timeutil.Clock) (tf TempFile, err error)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL