func TestReader(t *testing.T) { fake, cleanup := jiritest.NewFakeJiriRoot(t) defer cleanup() rd, err := profilesreader.NewReader(fake.X, profilesreader.UseProfiles, filepath.Join("testdata", "m2.xml")) if err != nil { t.Fatal(err) } rd.Vars = envvar.VarsFromOS() rd.Delete("CGO_CFLAGS") native, err := profiles.NewTarget("amd64-darwin", "") if err != nil { t.Fatal(err) } rd.MergeEnvFromProfiles(profilesreader.JiriMergePolicies(), native, "test::go", "test::syncbase") if got, want := rd.Get("CGO_CFLAGS"), "-IX -IY -IA -IB"; got != want { t.Errorf("got %v, want %v", got, want) } if got, want := rd.DebugString(), "Root: "+fake.X.Root+` Path: testdata/m2.xml test:go: [email protected] dir: --env= envvars:[CGO_ENABLED=1 GOARCH=amd64 GOOS=darwin GOROOT=/goroot CGO_CFLAGS=-IX -IY] test:syncbase: amd64-darwin@1 dir: --env= envvars:[CGO_CFLAGS=-IA -IB CGO_LDFLAGS=-LA -LB] `; got != want { t.Errorf("got %v, want %v", got, want) } }
// WARNING: this function is in the proces of being removed and replaced // by the profiles based configuration (see jiri/profiles). Use // profiles.ConfigHelper instead of this for new code. // // JiriLegacyEnvironment returns the environment variables setting for the project. // The util package captures the original state of the relevant environment // variables when the tool is initialized and every invocation of this function // updates this original state according to the jiri tool configuration. // // By default, the Go and VDL workspaces are added to the GOPATH and VDLPATH // environment variables respectively. In addition, the JIRI_PROFILE // environment variable can be used to activate an environment variable setting // for various development profiles of the project (e.g. arm, android, java, or // nacl). Unlike the default setting, the setting enabled by the JIRI_PROFILE // environment variable can override existing environment. func JiriLegacyEnvironment(ctx *tool.Context) (*envvar.Vars, error) { env := envvar.VarsFromOS() root, err := project.JiriRoot() if err != nil { return nil, err } config, err := LoadConfig(ctx) if err != nil { return nil, err } env.Set("CGO_ENABLED", "1") if err := setGoPath(ctx, env, root, config); err != nil { return nil, err } if err := setVdlPath(ctx, env, root, config); err != nil { return nil, err } if profile := os.Getenv(jiriProfileEnv); profile != "" { fmt.Fprintf(ctx.Stdout(), `NOTE: Enabling environment variable setting for %q. This can override values of existing environment variables. `, profile) switch profile { case "android": // Cross-compilation for android on linux. if err := setAndroidEnv(ctx, env, root); err != nil { return nil, err } case "arm": // Cross-compilation for arm on linux. if err := setArmEnv(ctx, env, root); err != nil { return nil, err } case "java": // Building of a Go shared library for Java. if err := setJavaEnv(ctx, env, root); err != nil { return nil, err } case "nacl": // Cross-compilation for nacl. if err := setNaclEnv(ctx, env, root); err != nil { return nil, err } default: fmt.Fprintf(ctx.Stderr(), "Unknown environment profile %q", profile) } } if err := setSyncbaseEnv(ctx, env, root); err != nil { return nil, err } return env, nil }
func TestConfigHelper(t *testing.T) { ctx := tool.NewDefaultContext() ch, err := profiles.NewConfigHelper(ctx, profiles.UseProfiles, "release/go/src/v.io/jiri/profiles/testdata/m2.xml") if err != nil { t.Fatal(err) } ch.Vars = envvar.VarsFromOS() ch.Delete("CGO_CFLAGS") target, _ := profiles.NewTarget("native=") ch.SetEnvFromProfiles(profiles.CommonConcatVariables(), map[string]bool{}, "go,syncbase", target) if got, want := ch.Get("CGO_CFLAGS"), "-IX -IY -IA -IB"; got != want { t.Errorf("got %v, want %v", got, want) } }
// NewConfigHelper creates a new config helper. If filename is of non-zero // length then that file will be read as a profiles manifest file, if not, the // existing, if any, in-memory profiles information will be used. If SkipProfiles // is specified for profilesMode, then no profiles are used. func NewConfigHelper(ctx *tool.Context, profilesMode ProfilesMode, filename string) (*ConfigHelper, error) { root, err := project.JiriRoot() if err != nil { return nil, err } config, err := util.LoadConfig(ctx) if err != nil { return nil, err } projects, tools, err := project.ReadManifest(ctx) if err != nil { return nil, err } if profilesMode == UseProfiles && len(filename) > 0 { if err := Read(ctx, filepath.Join(root, filename)); err != nil { return nil, err } } ch := &ConfigHelper{ ctx: ctx, root: root, config: config, projects: projects, tools: tools, profilesMode: bool(profilesMode), } ch.Vars = envvar.VarsFromOS() if profilesMode == SkipProfiles { return ch, nil } ch.legacyMode = (SchemaVersion() == Original) || (len(os.Getenv("JIRI_PROFILE")) > 0) if ch.legacyMode { vars, err := util.JiriLegacyEnvironment(ch.ctx) if err != nil { return nil, err } ch.Vars = vars } return ch, nil }
// NewReader creates a new profiles reader. If path is of non-zero // length then that path will be read as a profiles database, if not, the // existing, if any, in-memory profiles information will be used. If SkipProfiles // is specified for profilesMode, then no profiles are used. func NewReader(jirix *jiri.X, profilesMode ProfilesMode, path string) (*Reader, error) { pdb := profiles.NewDB() if profilesMode == UseProfiles && len(path) > 0 { if err := pdb.Read(jirix, path); err != nil { return nil, err } } rd := &Reader{ jirix: jirix, path: path, profilesMode: bool(profilesMode), pdb: pdb, } rd.Vars = envvar.VarsFromOS() if profilesMode == SkipProfiles { return rd, nil } if len(os.Getenv("JIRI_PROFILE")) > 0 { return nil, fmt.Errorf(`old style profiles are no longer supported. Please do not set JIRI_PROFILE.`) } return rd, nil }
func testSetPathHelper(t *testing.T, name string) { profiles.Clear() ctx := tool.NewDefaultContext() // Setup a fake JIRI_ROOT. root, err := project.NewFakeJiriRoot(ctx) if err != nil { t.Fatalf("%v", err) } defer func() { if err := root.Cleanup(ctx); err != nil { t.Fatalf("%v", err) } }() // Create a test project and identify it as a Go workspace. if err := root.CreateRemoteProject(ctx, "test"); err != nil { t.Fatalf("%v", err) } if err := root.AddProject(ctx, project.Project{ Name: "test", Path: "test", Remote: root.Projects["test"], }); err != nil { t.Fatalf("%v", err) } if err := root.UpdateUniverse(ctx, false); err != nil { t.Fatalf("%v", err) } var config *util.Config switch name { case "GOPATH": config = util.NewConfig(util.GoWorkspacesOpt([]string{"test", "does/not/exist"})) case "VDLPATH": config = util.NewConfig(util.VDLWorkspacesOpt([]string{"test", "does/not/exist"})) } oldRoot, err := project.JiriRoot() if err := os.Setenv("JIRI_ROOT", root.Dir); err != nil { t.Fatalf("%v", err) } defer os.Setenv("JIRI_ROOT", oldRoot) if err := profiles.Write(ctx, filepath.Join(root.Dir, "profiles-manifest")); err != nil { t.Fatal(err) } if err := util.SaveConfig(ctx, config); err != nil { t.Fatalf("%v", err) } // Retrieve Jiri_ROOT through JiriRoot() to account for symlinks. jiriRoot, err := project.JiriRoot() if err != nil { t.Fatalf("%v", err) } ch, err := profiles.NewConfigHelper(ctx, profiles.UseProfiles, "profiles-manifest") if err != nil { t.Fatal(err) } ch.Vars = envvar.VarsFromOS() ch.Set(name, "") var want string switch name { case "GOPATH": want = filepath.Join(jiriRoot, "test") ch.SetGoPath() case "VDLPATH": // Make a fake src directory. want = filepath.Join(jiriRoot, "test", "src") if err := ctx.Run().MkdirAll(want, 0755); err != nil { t.Fatalf("%v", err) } ch.SetVDLPath() } if got := ch.Get(name); got != want { t.Fatalf("unexpected value: got %v, want %v", got, want) } }