| // Copyright 2020 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| // Package workspace let's you manage workspaces |
| package workspace |
| |
| import ( |
| "fmt" |
| "io/ioutil" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "strings" |
| |
| "android.googlesource.com/platform/tools/treble.git/hacksaw/bind" |
| "android.googlesource.com/platform/tools/treble.git/hacksaw/codebase" |
| "android.googlesource.com/platform/tools/treble.git/hacksaw/config" |
| "android.googlesource.com/platform/tools/treble.git/hacksaw/git" |
| ) |
| |
| type Workspace struct { |
| composer Composer |
| topDir string |
| } |
| |
| func New(bm bind.PathBinder, topDir string) Workspace { |
| return Workspace{NewComposer(bm), topDir} |
| } |
| |
| // Create workspace |
| func (w Workspace) Create(workspaceName string, codebaseName string) (string, error) { |
| cfg := config.GetConfig() |
| _, ok := cfg.Codebases[codebaseName] |
| if !ok { |
| return "", fmt.Errorf("Codebase %s does not exist", codebaseName) |
| } |
| if _, ok := cfg.Workspaces[workspaceName]; ok { |
| return "", fmt.Errorf("Workspace %s already exists", workspaceName) |
| } |
| cfg.Workspaces[workspaceName] = codebaseName |
| workspaceDir, err := w.GetDir(workspaceName) |
| if err != nil { |
| return "", err |
| } |
| if err = os.MkdirAll(workspaceDir, os.ModePerm); err != nil { |
| return "", err |
| } |
| codebaseDir, err := codebase.GetDir(codebaseName) |
| if err != nil { |
| return "", err |
| } |
| //TODO: match the order of parameters with Create |
| if _, err = w.composer.Compose(codebaseDir, workspaceDir); err != nil { |
| return "", err |
| } |
| return workspaceDir, nil |
| } |
| |
| // Recreate workspace |
| func (w Workspace) Recreate(workspaceName string) (string, error) { |
| cfg := config.GetConfig() |
| codebaseName, ok := cfg.Workspaces[workspaceName] |
| if !ok { |
| return "", fmt.Errorf("Workspace %s does not exist", workspaceName) |
| } |
| workspaceDir, err := w.GetDir(workspaceName) |
| if err != nil { |
| return "", err |
| } |
| codebaseDir, err := codebase.GetDir(codebaseName) |
| if err != nil { |
| return "", err |
| } |
| if _, err = w.composer.Compose(codebaseDir, workspaceDir); err != nil { |
| return "", err |
| } |
| return workspaceDir, nil |
| } |
| |
| // GetDir retrieves the directory of a specific workspace |
| func (w Workspace) GetDir(workspaceName string) (string, error) { |
| cfg := config.GetConfig() |
| _, ok := cfg.Workspaces[workspaceName] |
| if !ok { |
| return "", fmt.Errorf("Workspace %s not found", workspaceName) |
| } |
| dir := filepath.Join(w.topDir, workspaceName) |
| return dir, nil |
| } |
| |
| // GetCodebase retrieves the codebase that a workspace belongs to |
| func (w Workspace) GetCodebase(workspaceName string) (string, error) { |
| cfg := config.GetConfig() |
| codebase, ok := cfg.Workspaces[workspaceName] |
| if !ok { |
| return "", fmt.Errorf("Workspace %s not found", workspaceName) |
| } |
| return codebase, nil |
| } |
| |
| //SetTopDir sets the directory that contains all workspaces |
| func (w *Workspace) SetTopDir(dir string) { |
| w.topDir = dir |
| } |
| |
| func (w Workspace) List() map[string]string { |
| cfg := config.GetConfig() |
| list := make(map[string]string) |
| for name, codebaseName := range cfg.Workspaces { |
| list[name] = codebaseName |
| } |
| return list |
| } |
| |
| func (w Workspace) DetachGitWorktrees(workspaceName string, unbindList []string) error { |
| workspaceDir, err := w.GetDir(workspaceName) |
| if err != nil { |
| return err |
| } |
| workspaceDir, err = filepath.Abs(workspaceDir) |
| if err != nil { |
| return err |
| } |
| //resolve all symlinks so it can be |
| //matched to mount paths |
| workspaceDir, err = filepath.EvalSymlinks(workspaceDir) |
| if err != nil { |
| return err |
| } |
| codebaseName, err := w.GetCodebase(workspaceName) |
| if err != nil { |
| return err |
| } |
| codebaseDir, err := codebase.GetDir(codebaseName) |
| if err != nil { |
| return err |
| } |
| lister := git.NewRepoLister() |
| gitProjects, err := lister.List(codebaseDir) |
| if err != nil { |
| return err |
| } |
| gitWorktrees := make(map[string]bool) |
| for _, project := range gitProjects { |
| gitWorktrees[project] = true |
| } |
| //projects that were unbound were definitely |
| //never git worktrees |
| for _, unbindPath := range unbindList { |
| project, err := filepath.Rel(workspaceDir, unbindPath) |
| if err != nil { |
| return err |
| } |
| if _, ok := gitWorktrees[project]; ok { |
| gitWorktrees[project] = false |
| } |
| } |
| for project, isWorktree := range gitWorktrees { |
| if !isWorktree { |
| continue |
| } |
| codebaseProject := filepath.Join(codebaseDir, project) |
| workspaceProject := filepath.Join(workspaceDir, project) |
| _, err = os.Stat(workspaceProject) |
| if err == nil { |
| //proceed to detach |
| } else if os.IsNotExist(err) { |
| //just skip if it doesn't exist |
| continue |
| } else { |
| return err |
| } |
| contents, err := ioutil.ReadDir(workspaceProject) |
| if err != nil { |
| return err |
| } |
| if len(contents) == 0 { |
| //empty directory, not even a .git |
| //not a wortree |
| continue |
| } |
| fmt.Print(".") |
| cmd := exec.Command("git", |
| "-C", codebaseProject, |
| "worktree", "remove", "--force", workspaceProject) |
| output, err := cmd.CombinedOutput() |
| if err != nil { |
| return fmt.Errorf("Command\n%s\nfailed with the following:\n%s\n%s", |
| cmd.String(), err.Error(), output) |
| } |
| cmd = exec.Command("git", |
| "-C", codebaseProject, |
| "branch", "--delete", "--force", workspaceName) |
| output, err = cmd.CombinedOutput() |
| if err != nil { |
| return fmt.Errorf("Command\n%s\nfailed with the following:\n%s\n%s", |
| cmd.String(), err.Error(), output) |
| } |
| } |
| return nil |
| } |
| |
| func (w Workspace) Remove(remove string) (*config.Config, error) { |
| cfg := config.GetConfig() |
| _, ok := cfg.Workspaces[remove] |
| if !ok { |
| return cfg, fmt.Errorf("Workspace %s not found", remove) |
| } |
| workspaceDir, err := w.GetDir(remove) |
| if err != nil { |
| return cfg, err |
| } |
| unbindList, err := w.composer.Dismantle(workspaceDir) |
| if err != nil { |
| return cfg, err |
| } |
| fmt.Print("Detaching worktrees") |
| if err = w.DetachGitWorktrees(remove, unbindList); err != nil { |
| return cfg, err |
| } |
| fmt.Print("\n") |
| fmt.Println("Removing files") |
| if err = os.RemoveAll(workspaceDir); err != nil { |
| return cfg, err |
| } |
| delete(cfg.Workspaces, remove) |
| return cfg, err |
| } |
| |
| func (w Workspace) Edit(editPath string) (string, string, error) { |
| editPath, err := filepath.Abs(editPath) |
| if err != nil { |
| return "", "", err |
| } |
| editPath, err = filepath.EvalSymlinks(editPath) |
| if err != nil { |
| return "", "", err |
| } |
| relProjectPath, err := w.getReadOnlyProjectFromPath(editPath) |
| if err != nil { |
| return "", "", err |
| } |
| workspaceName, err := w.getWorkspaceFromPath(editPath) |
| if err != nil { |
| return "", "", err |
| } |
| workspaceDir, err := w.GetDir(workspaceName) |
| if err != nil { |
| return "", "", err |
| } |
| codebaseName, err := w.GetCodebase(workspaceName) |
| if err != nil { |
| return "", "", err |
| } |
| codebaseDir, err := codebase.GetDir(codebaseName) |
| if err != nil { |
| return "", "", err |
| } |
| wsProjectPath := filepath.Join(workspaceDir, relProjectPath) |
| if err = w.composer.Unbind(wsProjectPath); err != nil { |
| return "", "", err |
| } |
| //TODO: support editing nested projects |
| //the command above unbinds nested child projects but |
| //we don't rebind them after checking out an editable project branch |
| cbProjectPath := filepath.Join(codebaseDir, relProjectPath) |
| branchName := workspaceName |
| cmd := exec.Command("git", |
| "-C", cbProjectPath, |
| "worktree", "add", |
| "-b", branchName, |
| wsProjectPath) |
| output, err := cmd.CombinedOutput() |
| if err != nil { |
| return "", "", fmt.Errorf("Command\n%s\nfailed with the following:\n%s\n%s", |
| cmd.String(), err.Error(), output) |
| } |
| return branchName, wsProjectPath, err |
| } |
| |
| func (w Workspace) getReadOnlyProjectFromPath(inPath string) (string, error) { |
| worspaceName, err := w.getWorkspaceFromPath(inPath) |
| if err != nil { |
| return "", err |
| } |
| workspacePath, err := w.GetDir(worspaceName) |
| if err != nil { |
| return "", err |
| } |
| bindList, err := w.composer.List(workspacePath) |
| if err != nil { |
| return "", err |
| } |
| for _, bindPath := range bindList { |
| if !strings.HasPrefix(inPath+"/", bindPath+"/") { |
| continue |
| } |
| relProjectPath, err := filepath.Rel(workspacePath, bindPath) |
| if err != nil { |
| return "", err |
| } |
| return relProjectPath, nil |
| } |
| return "", fmt.Errorf("Path %s is already editable", inPath) |
| } |
| |
| func (w Workspace) getWorkspaceFromPath(inPath string) (string, error) { |
| for workspaceName, _ := range w.List() { |
| dir, err := w.GetDir(workspaceName) |
| if err != nil { |
| return "", err |
| } |
| if strings.HasPrefix(inPath+"/", dir+"/") { |
| return workspaceName, nil |
| } |
| } |
| return "", fmt.Errorf("Path %s is not contained in a workspace", inPath) |
| } |
