blob: a9c0702b0e56f1afdeb33d1e5adaf6e74b93cd89 [file] [log] [blame]
// 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 profiles
import (
"fmt"
"os"
"runtime"
"sort"
"strings"
"time"
"v.io/x/lib/envvar"
)
// Target represents specification for the environment that the profile is
// to be built for. Targets include a version string to allow for upgrades and
// for the simultaneous existence of incompatible versions.
//
// Target and Environment implement flag.Getter so that they may be used
// with the flag package. Two flags are required, one to specify the target
// in <arch>-<os>@<version> format and a second to specify environment
// variables either as comma separated values or as repeated arguments.
type Target struct {
arch, opsys, version string
// The environment as specified on the command line
commandLineEnv Environment
// The environment as modified by a profile implementation
Env Environment
InstallationDir string // where this target is installed.
UpdateTime time.Time
isSet bool
}
// Arch returns the archiecture of this target.
func (pt *Target) Arch() string {
return pt.arch
}
// OS returns the operating system of this target.
func (pt *Target) OS() string {
return pt.opsys
}
// Version returns the version of this target.
func (pt *Target) Version() string {
return pt.version
}
// SetVersion sets the version for the target.
func (pt *Target) SetVersion(v string) {
pt.version = v
}
// CommandLineEnv returns the environment variables set on the
// command line for this target.
func (pt Target) CommandLineEnv() Environment {
r := Environment{Vars: make([]string, len(pt.commandLineEnv.Vars))}
copy(r.Vars, pt.commandLineEnv.Vars)
return r
}
// UseCommandLineEnv copies the command line supplied environment variables
// into the mutable environment of the Target. It should be called as soon
// as all command line parsing has been completed and before the target is
// otherwise used.
func (pt *Target) UseCommandLineEnv() {
pt.Env = pt.CommandLineEnv()
}
// TargetSpecificDirname returns a directory name that is specific
// to that target taking account the architecture, operating system and
// command line environment variables, if relevant, into account (e.g
// GOARM={5,6,7}).
func (pt *Target) TargetSpecificDirname() string {
env := envvar.SliceToMap(pt.commandLineEnv.Vars)
dir := pt.arch + "_" + pt.opsys
if pt.arch == "arm" {
if armv, present := env["GOARM"]; present {
dir += "_armv" + armv
}
}
return dir
}
type Environment struct {
Vars []string `xml:"var"`
}
// NewTarget creates a new target using the supplied target and environment
// parameters specified in command line format.
func NewTarget(target string, env ...string) (Target, error) {
t := &Target{}
err := t.Set(target)
for _, e := range env {
t.commandLineEnv.Set(e)
}
return *t, err
}
// Match returns true if pt and pt2 meet the following criteria in the
// order they are listed:
// - if the Arch and OS fields are exactly the same
// - if pt has a non-zero length Version field, then it must be
// the same as that in pt2
// Match is used by the various methods and functions in this package
// when looking up Targets unless otherwise specified.
func (pt Target) Match(pt2 *Target) bool {
if pt.arch != pt2.arch || pt.opsys != pt2.opsys {
return false
}
if (len(pt.version) > 0) && (pt.version != pt2.version) {
return false
}
return true
}
// Less returns true if pt2 is considered less than pt. The ordering
// takes into account only the architecture, operating system and version of
// the target. The architecture and operating system are ordered
// lexicographically in ascending order, then the version is ordered but in
// descending lexicographic order except that the empty string is considered
// the 'highest' value.
// Thus, (targets in <arch>-<os>[@<version>] format), are all true:
// b-c < c-c
// b-c@3 < b-c@2
func (pt *Target) Less(pt2 *Target) bool {
switch {
case pt.arch != pt2.arch:
return pt.arch < pt2.arch
case pt.opsys != pt2.opsys:
return pt.opsys < pt2.opsys
case len(pt.version) == 0 && len(pt2.version) > 0:
return true
case len(pt.version) > 0 && len(pt2.version) == 0:
return false
case pt.version != pt2.version:
return pt.version > pt2.version
default:
return false
}
}
// CrossCompiling returns true if the target differs from that of the runtime.
func (pt Target) CrossCompiling() bool {
arch, _ := goarch()
return (pt.arch != arch) || (pt.opsys != runtime.GOOS)
}
// Usage returns the usage string for Target.
func (pt *Target) Usage() string {
return "specifies a profile target in the following form: <arch>-<os>[@<version>]"
}
// Set implements flag.Value.
func (t *Target) Set(val string) error {
index := strings.IndexByte(val, '@')
if index > -1 {
t.version = val[index+1:]
val = val[:index]
}
parts := strings.Split(val, "-")
if len(parts) != 2 || (len(parts[0]) == 0 || len(parts[1]) == 0) {
return fmt.Errorf("%q doesn't look like <arch>-<os>[@<version>]", val)
}
t.arch = parts[0]
t.opsys = parts[1]
t.isSet = true
return nil
}
// Get implements flag.Getter.
func (t Target) Get() interface{} {
if !t.isSet {
// Default value.
arch, isSet := goarch()
return Target{
isSet: isSet,
arch: arch,
opsys: runtime.GOOS,
version: t.version,
Env: t.Env,
}
}
return t
}
func goarch() (string, bool) {
// GOARCH may be set to 386 for binaries compiled for amd64 - i.e.
// the same binary can be run in these two modes, but the compiled
// in value of runtime.GOARCH will only ever be the value that it
// was compiled with.
if a := os.Getenv("GOARCH"); len(a) > 0 {
return a, true
}
return runtime.GOARCH, false
}
// DefaultTarget returns a default value for a Target. Use this function to
// initialize Targets that are expected to set from the command line via
// the flags package.
func DefaultTarget() Target {
arch, isSet := goarch()
return Target{
isSet: isSet,
arch: arch,
opsys: runtime.GOOS,
}
}
// NativeTarget returns a value for Target for the host on which it is running.
// Use this function for Target values that are passed into other functions
// and libraries where a native target is specifically required.
func NativeTarget() Target {
arch, _ := goarch()
return Target{
isSet: true,
arch: arch,
opsys: runtime.GOOS,
}
}
// IsSet returns true if this target has had its value set.
func (pt Target) IsSet() bool {
return pt.isSet
}
// String implements flag.Getter.
func (pt Target) String() string {
v := pt.Get().(Target)
return fmt.Sprintf("%v-%v@%s", v.arch, v.opsys, v.version)
}
// Targets is a list of *Target's ordered by architecture,
// operating system and descending versions.
type Targets []*Target
// Implements sort.Len
func (tl Targets) Len() int {
return len(tl)
}
// Implements sort.Less
func (tl Targets) Less(i, j int) bool {
return tl[i].Less(tl[j])
}
// Implements sort.Swap
func (tl Targets) Swap(i, j int) {
tl[i], tl[j] = tl[i], tl[j]
}
func (tl Targets) Sort() {
sort.Sort(tl)
}
// DebugString returns a pretty-printed representation of pt.
func (pt Target) DebugString() string {
v := pt.Get().(Target)
return fmt.Sprintf("%v-%v@%s dir:%s --env=%s envvars:%v", v.arch, v.opsys, v.version, pt.InstallationDir, strings.Join(pt.commandLineEnv.Vars, ","), pt.Env.Vars)
}
// Set implements flag.Getter.
func (e *Environment) Get() interface{} {
return *e
}
// Set implements flag.Value.
func (e *Environment) Set(val string) error {
for _, v := range strings.Split(val, ",") {
parts := strings.SplitN(v, "=", 2)
if len(parts) != 2 || (len(parts[0]) == 0) {
return fmt.Errorf("%q doesn't look like var=[val]", v)
}
e.Vars = append(e.Vars, v)
}
return nil
}
// String implements flag.Getter.
func (e Environment) String() string {
return strings.Join(e.Vars, ",")
}
// Usage returns the usage string for Environment.
func (e Environment) Usage() string {
return "specify an environment variable in the form: <var>=[<val>],..."
}
// InsertTarget inserts the given target into Targets if it's not
// already there and returns a new slice.
func InsertTarget(targets Targets, target *Target) Targets {
for i, t := range targets {
if !t.Less(target) {
targets = append(targets, nil)
copy(targets[i+1:], targets[i:])
targets[i] = target
return targets
}
}
return append(targets, target)
}
// RemoveTarget removes the given target from a slice of Target and returns
// a slice.
func RemoveTarget(targets Targets, target *Target) Targets {
for i, t := range targets {
if target.Match(t) {
targets, targets[len(targets)-1] = append(targets[:i], targets[i+1:]...), nil
return targets
}
}
return targets
}
// FindTarget returns the first target that matches the requested target from
// the slice of Targets. If target has not been explicitly set and there is
// only a single target available in targets then that one target is considered
// as matching.
func FindTarget(targets Targets, target *Target) *Target {
for _, t := range targets {
if target.Match(t) {
tmp := *t
return &tmp
}
}
return nil
}
// FindTargetWithDefault is like FindTarget except that if there is only one
// target in the slice and the requested target has not been explicitly set
// (IsSet is false) then that one target is returned by default.
func FindTargetWithDefault(targets Targets, target *Target) *Target {
if len(targets) == 1 && !target.IsSet() {
tmp := *targets[0]
return &tmp
}
return FindTarget(targets, target)
}