only use vhd when there is a disk limit configured

This commit is contained in:
DaneEveritt 2022-10-29 13:01:04 -07:00
parent ff4b7655c8
commit daa0ab75b4
No known key found for this signature in database
GPG Key ID: EEA66103B3D71F53
2 changed files with 41 additions and 29 deletions

View File

@ -45,8 +45,8 @@ func (fs *Filesystem) SetDiskLimit(i int64) {
atomic.SwapInt64(&fs.diskLimit, i) atomic.SwapInt64(&fs.diskLimit, i)
} }
// The same concept as HasSpaceAvailable however this will return an error if there is // HasSpaceErr is the same concept as HasSpaceAvailable however this will return
// no space, rather than a boolean value. // an error if there is no space, rather than a boolean value.
func (fs *Filesystem) HasSpaceErr(allowStaleValue bool) error { func (fs *Filesystem) HasSpaceErr(allowStaleValue bool) error {
if !fs.HasSpaceAvailable(allowStaleValue) { if !fs.HasSpaceAvailable(allowStaleValue) {
return newFilesystemError(ErrCodeDiskSpace, nil) return newFilesystemError(ErrCodeDiskSpace, nil)
@ -54,30 +54,32 @@ func (fs *Filesystem) HasSpaceErr(allowStaleValue bool) error {
return nil return nil
} }
// Determines if the directory a file is trying to be added to has enough space available // HasSpaceAvailable determines if the directory a file is trying to be added to
// for the file to be written to. // has enough space available for the file to be written to.
// //
// Because determining the amount of space being used by a server is a taxing operation we // Because determining the amount of space being used by a server is a taxing
// will load it all up into a cache and pull from that as long as the key is not expired. // operation we will load it all up into a cache and pull from that as long as
// the key is not expired. This operation will potentially block unless
// allowStaleValue is set to true. See the documentation on DiskUsage for how
// this affects the call.
// //
// This operation will potentially block unless allowStaleValue is set to true. See the // If the current size of the disk is larger than the maximum allowed size this
// documentation on DiskUsage for how this affects the call. // function will return false, in all other cases it will return true. We do
// not check the existence of a virtual disk at this point since this logic is
// used to return friendly error messages to users, and also prevent us wasting
// time on more taxing operations when we know the result will end up failing due
// to space limits.
//
// If the servers disk limit is set to 0 it means there is no limit, however the
// DiskUsage method is still called to keep the cache warm. This function will
// always return true for a server with no limit set.
func (fs *Filesystem) HasSpaceAvailable(allowStaleValue bool) bool { func (fs *Filesystem) HasSpaceAvailable(allowStaleValue bool) bool {
size, err := fs.DiskUsage(allowStaleValue) size, err := fs.DiskUsage(allowStaleValue)
if err != nil { if err != nil {
log.WithField("root", fs.root).WithField("error", err).Warn("failed to determine root fs directory size") log.WithField("root", fs.root).WithField("error", err).
Warn("failed to determine root fs directory size")
} }
return fs.MaxDisk() == 0 || size <= fs.MaxDisk()
// If space is -1 or 0 just return true, means they're allowed unlimited.
//
// Technically we could skip disk space calculation because we don't need to check if the
// server exceeds its limit but because this method caches the disk usage it would be best
// to calculate the disk usage and always return true.
if fs.MaxDisk() == 0 {
return true
}
return size <= fs.MaxDisk()
} }
// CachedUsage returns the cached value for the amount of disk space used by the // CachedUsage returns the cached value for the amount of disk space used by the
@ -107,17 +109,24 @@ func (fs *Filesystem) DiskUsage(allowStaleValue bool) (int64, error) {
return 0, nil return 0, nil
} }
if !fs.lastLookupTime.Get().After(time.Now().Add(time.Second * fs.diskCheckInterval * -1)) { since := time.Now().Add(time.Second * fs.diskCheckInterval * -1)
// If the last lookup time was before our calculated limit we will re-execute this
// checking logic. If the lookup time was after the oldest possible timestamp we will
// continue returning the cached value.
if fs.lastLookupTime.Get().Before(since) {
// If we are now allowing a stale response go ahead and perform the lookup and return the fresh // If we are now allowing a stale response go ahead and perform the lookup and return the fresh
// value. This is a blocking operation to the calling process. // value. This is a blocking operation to the calling process.
if !allowStaleValue { if !allowStaleValue {
return fs.updateCachedDiskUsage() return fs.updateCachedDiskUsage()
} else if !fs.lookupInProgress.Load() { }
// Otherwise, if we allow a stale value and there isn't a valid item in the cache and we aren't
// currently performing a lookup, just do the disk usage calculation in the background. // Otherwise, if we allow a stale value and there isn't a valid item in the cache and we aren't
// currently performing a lookup, just do the disk usage calculation in the background.
if !fs.lookupInProgress.Load() {
go func(fs *Filesystem) { go func(fs *Filesystem) {
if _, err := fs.updateCachedDiskUsage(); err != nil { if _, err := fs.updateCachedDiskUsage(); err != nil {
log.WithField("root", fs.root).WithField("error", err).Warn("failed to update fs disk usage from within routine") log.WithField("root", fs.root).WithField("error", err).
Warn("failed to update fs disk usage from within routine")
} }
}(fs) }(fs)
} }

View File

@ -54,7 +54,10 @@ func New(uuid string, size int64, denylist []string) *Filesystem {
denylist: ignore.CompileIgnoreLines(denylist...), denylist: ignore.CompileIgnoreLines(denylist...),
} }
if vhd.Enabled() { // If VHD support is enabled but this server is configured with no disk size
// limit we cannot actually use a virtual disk. In that case fall back to using
// the default driver.
if vhd.Enabled() && size > 0 {
fs.vhd = vhd.New(size, vhd.DiskPath(uuid), fs.root) fs.vhd = vhd.New(size, vhd.DiskPath(uuid), fs.root)
} }
@ -86,9 +89,9 @@ func (fs *Filesystem) File(p string) (*os.File, Stat, error) {
return f, st, nil return f, st, nil
} }
// Acts by creating the given file and path on the disk if it is not present already. If // Touch acts by creating the given file and path on the disk if it is not present
// it is present, the file is opened using the defaults which will truncate the contents. // already. If it is present, the file is opened using the defaults which will
// The opened file is then returned to the caller. // truncate the contents. The opened file is then returned to the caller.
func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) { func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
cleaned, err := fs.SafePath(p) cleaned, err := fs.SafePath(p)
if err != nil { if err != nil {