func runList(env *cmdline.Env, args []string) error {
ctx := tool.NewContextFromEnv(env)
if showManifestFlag {
data, err := ctx.Run().ReadFile(manifestFlag)
if err != nil {
return err
}
fmt.Fprintln(ctx.Stdout(), string(data))
return nil
}
if verboseFlag {
fmt.Fprintf(ctx.Stdout(), "Manifest: %s\n", manifestFlag)
}
if availableFlag {
if verboseFlag {
fmt.Fprintf(ctx.Stdout(), "Available Profiles:\n")
for _, name := range profiles.Managers() {
mgr := profiles.LookupManager(name)
vi := mgr.VersionInfo()
fmt.Fprintf(ctx.Stdout(), "%s: versions: %s - %s\n", name, vi.Default(), strings.Join(vi.Supported(), " "))
}
} else {
fmt.Fprintf(ctx.Stdout(), "%s\n", strings.Join(profiles.Managers(), ", "))
}
}
if err := profiles.Read(ctx, manifestFlag); err != nil {
fmt.Fprintf(ctx.Stderr(), "Failed to read manifest: %v", err)
return err
}
profileNames := args
if len(args) == 0 {
profileNames = profiles.Profiles()
}
availableNames := []string{}
for _, name := range profileNames {
if profiles.LookupProfile(name) != nil {
availableNames = append(availableNames, name)
}
}
if verboseFlag {
fmt.Fprintf(ctx.Stdout(), "Installed Profiles: ")
fmt.Fprintf(ctx.Stdout(), "%s\n", strings.Join(profiles.Profiles(), ", "))
for _, name := range availableNames {
profile := profiles.LookupProfile(name)
fmt.Fprintf(ctx.Stdout(), "Profile: %s @ %s\n", profile.Name, profile.Root)
for _, target := range profile.Targets() {
fmt.Fprintf(ctx.Stdout(), "\t%s\n", target.DebugString())
}
}
} else {
for _, name := range availableNames {
profile := profiles.LookupProfile(name)
for _, target := range profile.Targets() {
fmt.Fprintf(ctx.Stdout(), "%s %s\n", name, target)
}
}
}
return nil
}
func runUninstall(env *cmdline.Env, args []string) error {
ctx := tool.NewContextFromEnv(env)
if err := initCommand(ctx, args); err != nil {
return err
}
if allFlag && targetFlag.IsSet() {
return fmt.Errorf("don't specify a target in conjunction with --all")
}
if allFlag {
for _, name := range args {
profile := profiles.LookupProfile(name)
mgr := profiles.LookupManager(name)
if profile == nil || mgr == nil {
continue
}
mgr.SetRoot(rootDir)
for _, target := range profile.Targets() {
if err := mgr.Uninstall(ctx, *target); err != nil {
logResult(ctx, "Uninstall", mgr, *target, err)
return err
}
logResult(ctx, "Uninstall", mgr, *target, nil)
}
}
} else {
applyCommand(args, env, ctx, targetFlag,
func(mgr profiles.Manager, ctx *tool.Context, target profiles.Target) error {
err := mgr.Uninstall(ctx, target)
logResult(ctx, "Uninstall", mgr, target, err)
return err
})
}
return profiles.Write(ctx, manifestFlag)
}
func runRecreate(env *cmdline.Env, args []string) error {
ctx := tool.NewContextFromEnv(env)
if err := profiles.Read(ctx, manifestFlag); err != nil {
fmt.Fprintf(ctx.Stderr(), "Failed to read manifest: %v", err)
return err
}
profileNames := args
if len(args) == 0 {
profileNames = profiles.Profiles()
}
prefix := "jiri v23-profile install"
for _, name := range profileNames {
profile := profiles.LookupProfile(name)
if profile == nil {
return fmt.Errorf("Profile %v is not installed", name)
}
for _, target := range profile.Targets() {
fmt.Fprintf(ctx.Stdout(), "%s --target=%s", prefix, target)
cmdEnv := target.CommandLineEnv()
if len(cmdEnv.Vars) > 0 {
fmt.Fprintf(ctx.Stdout(), " --env=\"%s\"", strings.Join(cmdEnv.Vars, ","))
}
fmt.Fprintf(ctx.Stdout(), " %s\n", name)
}
}
return nil
}
func (p *myNewProfile) Uninstall(ctx *tool.Context, target profiles.Target) error {
profiles.RemoveProfileTarget(p.name, target)
if profiles.LookupProfile(p.name) == nil {
p.status = "uninstalled"
}
return nil
}
func (p *myNewProfile) String() string {
profile := profiles.LookupProfile(p.name)
if profile == nil {
return fmt.Sprintf("Profile: %s: %s\n", p.name, p.status)
}
return fmt.Sprintf("Profile: %s: %s\n%s\n", p.name, p.status, profile.Targets())
}
func TestRead(t *testing.T) {
profiles.Clear()
ctx := tool.NewDefaultContext()
if err := profiles.Read(ctx, "./testdata/m1.xml"); err != nil {
t.Fatal(err)
}
cmp := func(a, b []string) bool {
if len(a) != len(b) {
return false
}
for i, s := range a {
if s != b[i] {
return false
}
}
return true
}
names := profiles.Profiles()
sort.Strings(names)
if got, want := names, []string{"a", "b"}; !cmp(got, want) {
t.Errorf("got %v, want %v", got, want)
}
p := profiles.LookupProfile("a")
if got, want := p.Targets()[0].Tag(), "t1"; got != want {
t.Errorf("got %v, want %v", got, want)
}
if got, want := p.Targets()[0].OS(), "os1"; got != want {
t.Errorf("got %v, want %v", got, want)
}
if got, want := p.Targets()[1].Version(), "bar"; got != want {
t.Errorf("got %v, want %v", got, want)
}
}
func TestBackwardsCompatibility(t *testing.T) {
profiles.Clear()
getProfiles := func() []*profiles.Profile {
db := []*profiles.Profile{}
names := profiles.Profiles()
sort.Strings(names)
for _, name := range names {
db = append(db, profiles.LookupProfile(name))
}
return db
}
ctx := tool.NewDefaultContext()
if err := profiles.Read(ctx, "./testdata/legacy.xml"); err != nil {
t.Fatal(err)
}
if got, want := profiles.SchemaVersion(), profiles.Original; got != want {
t.Errorf("got %v, want %v", got, want)
}
oprofiles := getProfiles()
if got, want := len(oprofiles), 5; got != want {
t.Errorf("got %v, want %v", got, want)
}
filename := tmpFile()
defer os.RemoveAll(filepath.Dir(filename))
var t1 profiles.Target
t1.Set("tag=cpu,os")
profiles.AddProfileTarget("__first", t1)
if err := profiles.Write(ctx, filename); err != nil {
t.Fatal(err)
}
if err := profiles.Read(ctx, filename); err != nil {
t.Fatal(err)
}
if got, want := profiles.SchemaVersion(), profiles.V3; got != want {
t.Errorf("got %v, want %v", got, want)
}
nprofiles := getProfiles()
if got, want := len(nprofiles), 6; got != want {
t.Errorf("got %v, want %v", got, want)
}
if got, want := nprofiles[0].Name, "__first"; got != want {
t.Errorf("got %v, want %v", got, want)
}
for i, v := range nprofiles[1:] {
if got, want := v.Name, oprofiles[i].Name; got != want {
t.Errorf("got %v, want %v", got, want)
}
}
}
func TestInstallProfile(t *testing.T) {
profiles.Clear()
profiles.InstallProfile("a", "root1")
profiles.InstallProfile("a", "root2")
profile := profiles.LookupProfile("a")
if got, want := profile.Root, "root1"; got != want {
t.Errorf("got %v, want %v", got, want)
}
}
func runEnv(env *cmdline.Env, args []string) error {
if len(profileFlag) == 0 {
return fmt.Errorf("no profile was specified using --profile")
}
ctx := tool.NewContextFromEnv(env)
if err := profiles.Read(ctx, manifestFlag); err != nil {
return fmt.Errorf("Failed to read manifest: %v", err)
}
profile := profiles.LookupProfile(profileFlag)
if profile == nil {
return fmt.Errorf("profile %q is not installed", profileFlag)
}
target := profiles.FindTarget(profile.Targets(), &targetFlag)
if target == nil {
return fmt.Errorf("target %q is not installed for profile %q", targetFlag, profileFlag)
}
vars := envvar.SliceToMap(target.Env.Vars)
buf := bytes.Buffer{}
if len(args) == 0 {
for k, v := range vars {
buf.WriteString(fmt.Sprintf("%s=%q ", k, v))
}
for k, fn := range pseudoVariables {
buf.WriteString(fmt.Sprintf("%s=%q ", k, fn(target)))
}
} else {
for _, arg := range args {
name := strings.TrimSuffix(arg, "=")
trimmed := name != arg
for k, fn := range pseudoVariables {
if k == name {
buf.WriteString(expr(k, fn(target), trimmed))
}
}
for k, v := range vars {
if k == name {
buf.WriteString(expr(k, v, trimmed))
}
}
}
}
fmt.Fprintf(ctx.Stdout(), strings.TrimSuffix(buf.String(), " ")+"\n")
return nil
}
func runCleanup(env *cmdline.Env, args []string) error {
ctx := tool.NewContextFromEnv(env)
if len(args) == 0 {
args = profiles.Managers()
}
if err := initCommand(ctx, args); err != nil {
return err
}
for _, n := range args {
mgr := profiles.LookupManager(n)
vi := mgr.VersionInfo()
profile := profiles.LookupProfile(n)
for _, target := range profile.Targets() {
if vi.IsOlderThanDefault(target.Version()) {
err := mgr.Uninstall(ctx, *target)
logResult(ctx, "Cleanup", mgr, *target, err)
if err != nil {
return err
}
}
}
}
return profiles.Write(ctx, manifestFlag)
}
func runUpdate(env *cmdline.Env, args []string) error {
ctx := tool.NewContextFromEnv(env)
if len(args) == 0 {
args = profiles.Managers()
}
if err := initCommand(ctx, args); err != nil {
return err
}
for _, n := range args {
mgr := profiles.LookupManager(n)
profile := profiles.LookupProfile(n)
if profile == nil {
continue
}
vi := mgr.VersionInfo()
mgr.SetRoot(rootDir)
for _, target := range profile.Targets() {
if vi.IsNewerThanDefault(target.Version()) {
if verboseFlag {
fmt.Fprintf(ctx.Stdout(), "Updating %s %s from %q to %s\n", n, target, target.Version(), vi)
}
target.SetVersion(vi.Default())
err := mgr.Install(ctx, *target)
logResult(ctx, "Update", mgr, *target, err)
if err != nil {
return err
}
} else {
if verboseFlag {
fmt.Fprintf(ctx.Stdout(), "%s %s at %q is up to date(%s)\n", n, target, target.Version(), vi)
}
}
}
}
return profiles.Write(ctx, manifestFlag)
}
