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)
}
}