| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package main |
| |
| import ( |
| "fmt" |
| "os" |
| |
| "v.io/jiri/jiri" |
| "v.io/jiri/project" |
| "v.io/jiri/runutil" |
| "v.io/x/lib/cmdline" |
| ) |
| |
| var ( |
| // Flags for configuring project attributes. |
| flagImportName, flagImportPath, flagImportProtocol, flagImportRemoteBranch, flagImportRevision, flagImportRoot string |
| // Flags for controlling the behavior of the command. |
| flagImportMode importMode |
| flagImportOut string |
| ) |
| |
| func init() { |
| cmdImport.Flags.StringVar(&flagImportName, "name", "", `The name of the remote manifest project, used to disambiguate manifest projects with the same remote. Typically empty.`) |
| cmdImport.Flags.StringVar(&flagImportPath, "path", "", `Path to store the manifest project locally. Uses "manifest" if unspecified.`) |
| cmdImport.Flags.StringVar(&flagImportProtocol, "protocol", "git", `The version control protocol used by the remote manifest project.`) |
| cmdImport.Flags.StringVar(&flagImportRemoteBranch, "remotebranch", "master", `The branch of the remote manifest project to track.`) |
| cmdImport.Flags.StringVar(&flagImportRevision, "revision", "HEAD", `The revision of the remote manifest project to reset to during "jiri update".`) |
| cmdImport.Flags.StringVar(&flagImportRoot, "root", "", `Root to store the manifest project locally.`) |
| |
| cmdImport.Flags.Var(&flagImportMode, "mode", ` |
| The import mode: |
| append - Create file if it doesn't exist, or append to existing file. |
| overwrite - Write file regardless of whether it already exists. |
| `) |
| cmdImport.Flags.StringVar(&flagImportOut, "out", "", `The output file. Uses $JIRI_ROOT/.jiri_manifest if unspecified. Uses stdout if set to "-".`) |
| } |
| |
| type importMode int |
| |
| const ( |
| importAppend importMode = iota |
| importOverwrite |
| ) |
| |
| func (m *importMode) Set(s string) error { |
| switch s { |
| case "append": |
| *m = importAppend |
| return nil |
| case "overwrite": |
| *m = importOverwrite |
| return nil |
| } |
| return fmt.Errorf("unknown import mode %q", s) |
| } |
| |
| func (m importMode) String() string { |
| switch m { |
| case importAppend: |
| return "append" |
| case importOverwrite: |
| return "overwrite" |
| } |
| return "UNKNOWN" |
| } |
| |
| func (m importMode) Get() interface{} { |
| return m |
| } |
| |
| var cmdImport = &cmdline.Command{ |
| Runner: jiri.RunnerFunc(runImport), |
| Name: "import", |
| Short: "Adds imports to .jiri_manifest file", |
| Long: ` |
| Command "import" adds imports to the $JIRI_ROOT/.jiri_manifest file, which |
| specifies manifest information for the jiri tool. The file is created if it |
| doesn't already exist, otherwise additional imports are added to the existing |
| file. The arguments and flags configure the <import> element that is added to |
| the manifest. |
| |
| Run "jiri help manifest" for details on manifests. |
| `, |
| ArgsName: "<remote> <manifest>", |
| ArgsLong: ` |
| <remote> specifies the remote repository that contains your manifest project. |
| |
| <manifest> specifies the manifest file to use from the manifest project. |
| `, |
| } |
| |
| func runImport(jirix *jiri.X, args []string) error { |
| if len(args) != 2 || args[0] == "" || args[1] == "" { |
| return jirix.UsageErrorf("must specify non-empty <remote> and <manifest>") |
| } |
| // Initialize manifest. |
| var manifest *project.Manifest |
| if flagImportMode == importAppend { |
| m, err := project.ManifestFromFile(jirix, jirix.JiriManifestFile()) |
| if err != nil && !runutil.IsNotExist(err) { |
| return err |
| } |
| manifest = m |
| } |
| if manifest == nil { |
| manifest = &project.Manifest{} |
| } |
| // Add remote import. |
| manifest.Imports = append(manifest.Imports, project.Import{ |
| Manifest: args[1], |
| Root: flagImportRoot, |
| Project: project.Project{ |
| Name: flagImportName, |
| Path: flagImportPath, |
| Protocol: flagImportProtocol, |
| Remote: args[0], |
| RemoteBranch: flagImportRemoteBranch, |
| Revision: flagImportRevision, |
| }, |
| }) |
| // Write output to stdout or file. |
| outFile := flagImportOut |
| if outFile == "" { |
| outFile = jirix.JiriManifestFile() |
| } |
| if outFile == "-" { |
| bytes, err := manifest.ToBytes() |
| if err != nil { |
| return err |
| } |
| _, err = os.Stdout.Write(bytes) |
| return err |
| } |
| return manifest.ToFile(jirix, outFile) |
| } |