mirror of https://github.com/databricks/cli.git
121 lines
3.8 KiB
Go
121 lines
3.8 KiB
Go
package mutator
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"path/filepath"
|
|
|
|
"github.com/databricks/cli/bundle"
|
|
"github.com/databricks/cli/libs/diag"
|
|
"github.com/databricks/cli/libs/dyn"
|
|
"github.com/databricks/cli/libs/vfs"
|
|
)
|
|
|
|
type syncInferRoot struct{}
|
|
|
|
// SyncInferRoot is a mutator that infers the root path of all files to synchronize by looking at the
|
|
// paths in the sync configuration. The sync root may be different from the bundle root
|
|
// when the user intends to synchronize files outside the bundle root.
|
|
//
|
|
// The sync root can be equivalent to or an ancestor of the bundle root, but not a descendant.
|
|
// That is, the sync root must contain the bundle root.
|
|
//
|
|
// This mutator requires all sync-related paths and patterns to be relative to the bundle root path.
|
|
// This is done by the [RewriteSyncPaths] mutator, which must run before this mutator.
|
|
func SyncInferRoot() bundle.Mutator {
|
|
return &syncInferRoot{}
|
|
}
|
|
|
|
func (m *syncInferRoot) Name() string {
|
|
return "SyncInferRoot"
|
|
}
|
|
|
|
// computeRoot finds the innermost path that contains the specified path.
|
|
// It traverses up the root path until it finds the innermost path.
|
|
// If the path does not exist, it returns an empty string.
|
|
//
|
|
// See "sync_infer_root_internal_test.go" for examples.
|
|
func (m *syncInferRoot) computeRoot(path string, root string) string {
|
|
for !filepath.IsLocal(path) {
|
|
// Break if we have reached the root of the filesystem.
|
|
dir := filepath.Dir(root)
|
|
if dir == root {
|
|
return ""
|
|
}
|
|
|
|
// Update the sync path as we navigate up the directory tree.
|
|
path = filepath.Join(filepath.Base(root), path)
|
|
|
|
// Move up the directory tree.
|
|
root = dir
|
|
}
|
|
|
|
return filepath.Clean(root)
|
|
}
|
|
|
|
func (m *syncInferRoot) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
|
|
var diags diag.Diagnostics
|
|
|
|
// Use the bundle root path as the starting point for inferring the sync root path.
|
|
bundleRootPath := filepath.Clean(b.BundleRootPath)
|
|
|
|
// Infer the sync root path by looking at each one of the sync paths.
|
|
// Every sync path must be a descendant of the final sync root path.
|
|
syncRootPath := bundleRootPath
|
|
for _, path := range b.Config.Sync.Paths {
|
|
computedPath := m.computeRoot(path, bundleRootPath)
|
|
if computedPath == "" {
|
|
continue
|
|
}
|
|
|
|
// Update sync root path if the computed root path is an ancestor of the current sync root path.
|
|
if len(computedPath) < len(syncRootPath) {
|
|
syncRootPath = computedPath
|
|
}
|
|
}
|
|
|
|
// The new sync root path can only be an ancestor of the previous root path.
|
|
// Compute the relative path from the sync root to the bundle root.
|
|
rel, err := filepath.Rel(syncRootPath, bundleRootPath)
|
|
if err != nil {
|
|
return diag.FromErr(err)
|
|
}
|
|
|
|
// If during computation of the sync root path we hit the root of the filesystem,
|
|
// then one or more of the sync paths are outside the filesystem.
|
|
// Check if this happened by verifying that none of the paths escape the root
|
|
// when joined with the sync root path.
|
|
for i, path := range b.Config.Sync.Paths {
|
|
if filepath.IsLocal(filepath.Join(rel, path)) {
|
|
continue
|
|
}
|
|
|
|
diags = append(diags, diag.Diagnostic{
|
|
Severity: diag.Error,
|
|
Summary: fmt.Sprintf("invalid sync path %q", path),
|
|
Locations: b.Config.GetLocations(fmt.Sprintf("sync.paths[%d]", i)),
|
|
Paths: []dyn.Path{dyn.NewPath(dyn.Key("sync"), dyn.Key("paths"), dyn.Index(i))},
|
|
})
|
|
}
|
|
|
|
if diags.HasError() {
|
|
return diags
|
|
}
|
|
|
|
// Update all paths in the sync configuration to be relative to the sync root.
|
|
for i, p := range b.Config.Sync.Paths {
|
|
b.Config.Sync.Paths[i] = filepath.Join(rel, p)
|
|
}
|
|
for i, p := range b.Config.Sync.Include {
|
|
b.Config.Sync.Include[i] = filepath.Join(rel, p)
|
|
}
|
|
for i, p := range b.Config.Sync.Exclude {
|
|
b.Config.Sync.Exclude[i] = filepath.Join(rel, p)
|
|
}
|
|
|
|
// Configure the sync root path.
|
|
b.SyncRoot = vfs.MustNew(syncRootPath)
|
|
b.SyncRootPath = syncRootPath
|
|
return nil
|
|
}
|