func safeName(name string) string {
	travis, haveTravis := syscall.Getenv("TRAVIS")
	buildId, haveBuildId := syscall.Getenv("TRAVIS_JOB_NUMBER")
	if !haveTravis || !haveBuildId || travis != "true" {
		return name
	}

	return name + "_travis-" + buildId
}
Exemplo n.º 2
0
func main() {
	es_access_key, ok := syscall.Getenv("ES_ACCESS_KEY")
	if ok != true {
		fmt.Printf("You must set the environment variable: ES_ACCESS_KEY\n")
		os.Exit(1)
	}
	es_secret_key, ok := syscall.Getenv("ES_SECRET_KEY")
	if ok != true {
		fmt.Printf("You must set the environment variable: ES_SECRET_KEY\n")
		os.Exit(1)
	}
	url := "https://api.enstratus.com/api/enstratus/2012-06-15/geography/Cloud"
	request, _ := http.NewRequest("GET", url, nil)
	request.Header.Add("accept", "application/json")
	request.Header.Add("x-esauth-access", es_access_key)
	request.Header.Add("x-esauth-timestamp", string(GetTimeString()))
	request.Header.Add("x-es-details", "basic")
	request.Header.Add("user-agent", ES_UA)
	sig := SignRequest(es_access_key, es_secret_key,
		ES_UA, "GET",
		"geography/Cloud")
	request.Header.Add("x-esauth-signature", sig)
	client := &http.Client{}
	response, err := client.Do(request)
	if err != nil {
		fmt.Printf("%s", err)
		os.Exit(1)
	} else {
		defer response.Body.Close()
		contents, err := ioutil.ReadAll(response.Body)
		if err != nil {
			fmt.Printf("%s", err)
			os.Exit(1)
		}
		switch {
		case response.StatusCode >= 400 && response.StatusCode <= 599:
			e := &EnstratusError{}
			err := json.Unmarshal([]byte(contents), &e)
			if err != nil {
				fmt.Printf("JSON Decoding error: %s\n", err)
				os.Exit(1)
			}
			fmt.Printf("%s\n", e.Error.Message)
			os.Exit(1)
		}
		clouds := &CloudList{}
		jsonerr := json.Unmarshal([]byte(contents), &clouds)
		if jsonerr != nil {
			fmt.Printf("JSON Decoding error: %s\n", jsonerr)
			os.Exit(1)
		}
		spew.Dump(clouds)
	}
}
Exemplo n.º 3
0
func getEnv(e1, e2, d string) string {

	if r, found := syscall.Getenv(e1); found {
		return r
	}

	if r, found := syscall.Getenv(e2); found {
		return r
	}

	return d
}
Exemplo n.º 4
0
func initLocal() {
	// consult $TZ to find the time zone to use.
	// no $TZ means use the system default /etc/localtime.
	// $TZ="" means use UTC.
	// $TZ="foo" means use /usr/share/zoneinfo/foo.

	tz, ok := syscall.Getenv("TZ")
	switch {
	case !ok:
		z, err := loadZoneFile("", "/etc/localtime")
		if err == nil {
			localLoc = *z
			localLoc.name = "Local"
			return
		}
	case tz != "" && tz != "UTC":
		if z, err := loadLocation(tz); err == nil {
			localLoc = *z
			return
		}
	}

	// Fall back to UTC.
	localLoc.name = "UTC"
}
Exemplo n.º 5
0
// ServerMode returns the Gin server mode as per environment or default.
func ServerMode() string {
	mode, ok := syscall.Getenv("SERVER_MODE")
	if !ok {
		mode = DefaultServerMode
	}
	return mode
}
Exemplo n.º 6
0
// ApplyWithError populates the flag given the flag set and environment
func (f BoolTFlag) ApplyWithError(set *flag.FlagSet) error {
	val := true
	if f.EnvVar != "" {
		for _, envVar := range strings.Split(f.EnvVar, ",") {
			envVar = strings.TrimSpace(envVar)
			if envVal, ok := syscall.Getenv(envVar); ok {
				if envVal == "" {
					val = false
					break
				}

				envValBool, err := strconv.ParseBool(envVal)
				if err != nil {
					return fmt.Errorf("could not parse %s as bool value for flag %s: %s", envVal, f.Name, err)
				}

				val = envValBool
				break
			}
		}
	}

	eachName(f.Name, func(name string) {
		if f.Destination != nil {
			set.BoolVar(f.Destination, name, val, f.Usage)
			return
		}
		set.Bool(name, val, f.Usage)
	})

	return nil
}
Exemplo n.º 7
0
Arquivo: udir.go Projeto: RC69/RCsite2
func main() {
	flag.Parse()
	dir := flag.Arg(0) // new directory x  | xx | xxx

	pwd, _ := syscall.Getenv("PWD") // ~/aaa/bbbb/xxx/yyy/zzzzz

	tb := str.Split(pwd, "/")

	newPath := ""
	isPresent := false
	for i := 0; i < len(tb); i++ {
		newPath += tb[i] + "/"
		if str.HasPrefix(tb[i], dir) {
			isPresent = true
			break
		}
	}

	if !isPresent {
		err := "Directory " + dir + " non trouvé dans path " + pwd
		fmt.Println(err)
		os.Exit(16) // echo $?
	}

	fmt.Println("cd " + newPath) // ~/aaa/bbbb/xxx/

}
Exemplo n.º 8
0
// ApplyWithError populates the flag given the flag set and environment
func (f DurationFlag) ApplyWithError(set *flag.FlagSet) error {
	if f.EnvVar != "" {
		for _, envVar := range strings.Split(f.EnvVar, ",") {
			envVar = strings.TrimSpace(envVar)
			if envVal, ok := syscall.Getenv(envVar); ok {
				envValDuration, err := time.ParseDuration(envVal)
				if err != nil {
					return fmt.Errorf("could not parse %s as duration for flag %s: %s", envVal, f.Name, err)
				}

				f.Value = envValDuration
				break
			}
		}
	}

	eachName(f.Name, func(name string) {
		if f.Destination != nil {
			set.DurationVar(f.Destination, name, f.Value, f.Usage)
			return
		}
		set.Duration(name, f.Value, f.Usage)
	})

	return nil
}
Exemplo n.º 9
0
// ApplyWithError populates the flag given the flag set and environment
func (f Float64Flag) ApplyWithError(set *flag.FlagSet) error {
	if f.EnvVar != "" {
		for _, envVar := range strings.Split(f.EnvVar, ",") {
			envVar = strings.TrimSpace(envVar)
			if envVal, ok := syscall.Getenv(envVar); ok {
				envValFloat, err := strconv.ParseFloat(envVal, 10)
				if err != nil {
					return fmt.Errorf("could not parse %s as float64 value for flag %s: %s", envVal, f.Name, err)
				}

				f.Value = float64(envValFloat)
				break
			}
		}
	}

	eachName(f.Name, func(name string) {
		if f.Destination != nil {
			set.Float64Var(f.Destination, name, f.Value, f.Usage)
			return
		}
		set.Float64(name, f.Value, f.Usage)
	})

	return nil
}
Exemplo n.º 10
0
func TestFixedGOROOT(t *testing.T) {
	if runtime.GOOS == "plan9" {
		t.Skipf("skipping plan9, it is inconsistent by allowing GOROOT to be updated by Setenv")
	}

	// Restore both the real GOROOT environment variable, and runtime's copies:
	if orig, ok := syscall.Getenv("GOROOT"); ok {
		defer syscall.Setenv("GOROOT", orig)
	} else {
		defer syscall.Unsetenv("GOROOT")
	}
	envs := runtime.Envs()
	oldenvs := append([]string{}, envs...)
	defer runtime.SetEnvs(oldenvs)

	// attempt to reuse existing envs backing array.
	want := runtime.GOROOT()
	runtime.SetEnvs(append(envs[:0], "GOROOT="+want))

	if got := runtime.GOROOT(); got != want {
		t.Errorf(`initial runtime.GOROOT()=%q, want %q`, got, want)
	}
	if err := syscall.Setenv("GOROOT", "/os"); err != nil {
		t.Fatal(err)
	}
	if got := runtime.GOROOT(); got != want {
		t.Errorf(`after setenv runtime.GOROOT()=%q, want %q`, got, want)
	}
	if err := syscall.Unsetenv("GOROOT"); err != nil {
		t.Fatal(err)
	}
	if got := runtime.GOROOT(); got != want {
		t.Errorf(`after unsetenv runtime.GOROOT()=%q, want %q`, got, want)
	}
}
Exemplo n.º 11
0
// ServerConfig returns the Gin server config as per environment or default.
func ServerConfig() string {
	addr, _ := syscall.Getenv("SERVER_ADDR")
	var port string
	if portStr, ok := syscall.Getenv("SERVER_PORT"); !ok {
		port = DefaultPort
	} else {
		portUInt, err := strconv.ParseUint(portStr, 10, 16)
		if err != nil || portUInt > 65535 {
			log.Notice("Invalid port \"%s\", using %s instead.", portStr, DefaultPort)
			port = DefaultPort
		} else {
			port = portStr
		}
	}
	return fmt.Sprintf("%s:%s", addr, port)
}
Exemplo n.º 12
0
func init() {
	switch path, _ := syscall.Getenv("GOCOVOUT"); path {
	case "":
		// No tracing
	case "-":
		Default.Tracer = fdwriter(syscall.Stdout)
	default:
		// Add the process ID to the filename.
		// TODO handle PID reuse by checking if file exists.
		path += "." + itoa(syscall.Getpid())

		mode := syscall.O_WRONLY | syscall.O_CREAT | syscall.O_TRUNC
		fd, err := syscall.Open(path, mode, 0666)
		if err != nil {
			msg := "gocov: failed to create log file: "
			msg += err.Error() + "\n"
			write(fdwriter(syscall.Stderr), []byte(msg))
			syscall.Exit(1)
		}
		Default.Tracer = fdwriter(int(fd))
	}

	// Remove GOCOVOUT from environ, to prevent noise from child processes.
	// TODO Don't do this; append .pid to output filename.
	syscall.Setenv("GOCOVOUT", "")
}
Exemplo n.º 13
0
// ApplyWithError populates the flag given the flag set and environment
func (f Int64SliceFlag) ApplyWithError(set *flag.FlagSet) error {
	if f.EnvVar != "" {
		for _, envVar := range strings.Split(f.EnvVar, ",") {
			envVar = strings.TrimSpace(envVar)
			if envVal, ok := syscall.Getenv(envVar); ok {
				newVal := &Int64Slice{}
				for _, s := range strings.Split(envVal, ",") {
					s = strings.TrimSpace(s)
					if err := newVal.Set(s); err != nil {
						return fmt.Errorf("could not parse %s as int64 slice value for flag %s: %s", envVal, f.Name, err)
					}
				}
				f.Value = newVal
				break
			}
		}
	}

	eachName(f.Name, func(name string) {
		if f.Value == nil {
			f.Value = &Int64Slice{}
		}
		set.Var(f.Value, name, f.Usage)
	})
	return nil
}
Exemplo n.º 14
0
Arquivo: xfcm.go Projeto: cabrel/xfcm
func init() {
	log.EnableDebugLogging()

	flag.StringVar(&add, "add", "", "Server to add to the connection manager")
	flag.StringVar(&connect, "connect", "", "Stored server to connect to")
	flag.StringVar(&domain, "domain", "", "AD domain")
	flag.StringVar(&ip, "ip", "", "Server ip address")
	flag.BoolVar(&list, "list", false, "List the stored servers")
	flag.BoolVar(&nla, "nla", true, "Use network level authentication (yes/no)")
	flag.BoolVar(&debug, "debug", false, "Enable debugging")
	flag.StringVar(&remove, "remove", "", "Server to remove from the connection manager")
	flag.StringVar(&username, "username", "", "AD username")
	flag.StringVar(&app, "app", "", "Remote Application")
	homePath, _ := syscall.Getenv("HOME")
	configFile = path.Join(homePath, ".xfcm")

	// check if the configuration file exists
	filePathExists, err := pathExists(configFile, true)

	// print if we encountered an error checking if the path existed
	if err != nil {
		log.Error(err)
	}

	// if the path didn't exist, create the file
	if !filePathExists {
		createConfigFile(configFile)
	}

}
Exemplo n.º 15
0
// applyWithError populates the flag given the flag set and environment
func (f UintFlag) applyWithError(set *flag.FlagSet) error {
	if f.EnvVar != "" {
		for _, envVar := range strings.Split(f.EnvVar, ",") {
			envVar = strings.TrimSpace(envVar)
			if envVal, ok := syscall.Getenv(envVar); ok {
				envValInt, err := strconv.ParseUint(envVal, 0, 64)
				if err != nil {
					return fmt.Errorf("could not parse %s as uint value for flag %s: %s", envVal, f.Name, err)
				}

				f.Value = uint(envValInt)
				break
			}
		}
	}

	eachName(f.Name, func(name string) {
		if f.Destination != nil {
			set.UintVar(f.Destination, name, f.Value, f.Usage)
			return
		}
		set.Uint(name, f.Value, f.Usage)
	})

	return nil
}
Exemplo n.º 16
0
func initLocal() { // 初始化location
	// consult $TZ to find the time zone to use.
	// no $TZ means use the system default /etc/localtime.
	// $TZ="" means use UTC.
	// $TZ="foo" means use /usr/share/zoneinfo/foo.

	tz, ok := syscall.Getenv("TZ") // 查询TZ变量
	switch {
	case !ok: // 如果不存在TZ变量
		z, err := loadZoneFile("", "/etc/localtime") // 从etc载入localtime文件
		if err == nil {                              // 如果没有错误
			localLoc = *z           // 设置localLoc
			localLoc.name = "Local" // 设置location名
			return
		}
	case tz != "" && tz != "UTC": // 存在tz变量,并且不等于空和UTC
		if z, err := loadLocation(tz); err == nil {
			localLoc = *z
			return
		}
	}

	// Fall back to UTC.
	localLoc.name = "UTC" // 设置location为UTC
}
Exemplo n.º 17
0
func loadString(name string, out *reflect.Value) {
	data, found := syscall.Getenv(name)
	if !found {
		return
	}

	out.SetString(data)
}
Exemplo n.º 18
0
func initTest(t *testing.T) (*Client, *Index) {
	appID, haveAppID := syscall.Getenv("ALGOLIA_APPLICATION_ID")
	apiKey, haveApiKey := syscall.Getenv("ALGOLIA_API_KEY")
	if !haveApiKey || !haveAppID {
		t.Fatalf("Need ALGOLIA_APPLICATION_ID and ALGOLIA_API_KEY")
	}
	client := NewClient(appID, apiKey)
	client.SetTimeout(1000, 10000)
	hosts := make([]string, 3)
	hosts[0] = appID + "-1.algolia.net"
	hosts[1] = appID + "-2.algolia.net"
	hosts[2] = appID + "-3.algolia.net"
	client = NewClientWithHosts(appID, apiKey, hosts)
	index := client.InitIndex(safeName("àlgol?à-go"))

	return client, index
}
Exemplo n.º 19
0
func readEnvParam(name string) syscall.Handle {
	v, _ := syscall.Getenv(name)
	var x uintptr
	for i := 0; i < len(v); i++ {
		x = x*10 + uintptr(v[i]-'0')
	}
	return syscall.Handle(x)
}
Exemplo n.º 20
0
func loadBool(name string, out *reflect.Value) {
	data, found := syscall.Getenv(name)
	if !found {
		return
	}

	result := data != "0" && data != "false"
	out.SetBool(result)
}
Exemplo n.º 21
0
// Fetch data from system env, based on existing config keys.
func (cfg *Config) Env() *Config {
	keys := getKeys(cfg.Root)
	for _, key := range keys {
		if val, exist := syscall.Getenv(strings.ToUpper(strings.Join(key, "_"))); exist {
			cfg.Set(strings.Join(key, "."), val)
		}
	}
	return cfg
}
Exemplo n.º 22
0
func Test_ReadEnv(t *testing.T) {
	clear()

	err := ReadEnv("test/.env")
	assert.NoError(t, err)
	assert.Equal(t, "jpfuentes2", os.Getenv("TWITTER"))
	assert.Equal(t, "jpfuentes2", os.Getenv("GITHUB"))
	assert.Equal(t, "http://jacquesfuentes.com", os.Getenv("WEB"))

	// should not exist
	_, found := syscall.Getenv("A_COMMENT")
	assert.False(t, found)

	// should exist but be blank
	blank, found := syscall.Getenv("BLANK_COMMENT")
	assert.True(t, found)
	assert.Equal(t, "", blank)
}
Exemplo n.º 23
0
// Getenverror retrieves the value of the environment variable named by the key.
// It returns the value and an error, if any.
func Getenverror(key string) (value string, err error) {
	if len(key) == 0 {
		return "", EINVAL
	}
	val, found := syscall.Getenv(key)
	if !found {
		return "", ENOENV
	}
	return val, nil
}
Exemplo n.º 24
0
func ExpandEnv(s string) string {
	return os.Expand(s, func(key string) string {
		if key == "$" {
			return key
		} else {
			v, _ := syscall.Getenv(key)
			return v
		}
	})
}
Exemplo n.º 25
0
func loadInteger(name string, out *reflect.Value) {
	data, found := syscall.Getenv(name)
	if !found {
		return
	}
	d, err := strconv.ParseInt(data, 10, 64)
	if err != nil {
		panic(fmt.Errorf("field type of %s cannot be parsed into integer", name))
	}

	out.SetInt(d)
}
Exemplo n.º 26
0
func isEnvVarSet(envVars string) bool {
	for _, envVar := range strings.Split(envVars, ",") {
		envVar = strings.TrimSpace(envVar)
		if _, ok := syscall.Getenv(envVar); ok {
			// TODO: Can't use this for bools as
			// set means that it was true or false based on
			// Bool flag type, should work for other types
			return true
		}
	}

	return false
}
Exemplo n.º 27
0
func testSetGetenv(t *testing.T, key, value string) {
	err := syscall.Setenv(key, value)
	if err != nil {
		t.Fatalf("Setenv failed to set %q: %v", value, err)
	}
	newvalue, found := syscall.Getenv(key)
	if !found {
		t.Fatalf("Getenv failed to find %v variable (want value %q)", key, value)
	}
	if newvalue != value {
		t.Fatalf("Getenv(%v) = %q; want %q", key, newvalue, value)
	}
}
Exemplo n.º 28
0
func ssh(instances *ec2.InstancesResp) {
	found := 0
	list := make([]string, 0)
	var name, address string
	for _, reservation := range instances.Reservations {
		for _, instance := range reservation.Instances {
			vpc := instance.VpcId
			name = "UNNAMED"
			for _, tag := range instance.Tags {
				if tag.Key == "Name" {
					name = tag.Value
				}
			}

			// print name
			dnsName := instance.DNSName
			if dnsName == "" {
				dnsName = "-"
			}
			ipAddress := instance.PrivateIpAddress
			if ipAddress == "" {
				ipAddress = "-"
			}
			if vpc != "" {
				address = ipAddress
			} else {
				address = dnsName
			}
			list = append(list, name+": "+address)
			found++
		}
	}
	if found > 1 {
		fmt.Println("Too many matches. Be more specific:")
		for _, item := range list {
			fmt.Println(item)
		}
		os.Exit(3)
	}
	fmt.Println("Launching SSH to", name, "at", address)
	sshCommand, err := exec.LookPath("ssh")
	if err != nil {
		fmt.Println("Couldn't find SSH...")
		os.Exit(5)
	}
	terminal, _ := syscall.Getenv("TERM")
	fmt.Println("Terminal:", terminal)
	//cmd := exec.Command("setterm", "-term "+terminal)
	//cmd.Run()
	syscall.Exec(sshCommand, []string{"ssh", address}, []string{"TERM=" + terminal})
}
Exemplo n.º 29
0
// Parse parses environment variables into v, which must be a pointer to a
// struct. Because of the way envvar uses reflection, the fields in v must be
// exported, i.e. start with a capital letter. For each field in v, Parse will
// get the environment variable with the same name as the field and set the
// field to the value of that environment variable, converting it to the
// appropriate type if needed.
//
// Parse supports two struct tags, which can be used together or separately. The
// struct tag `envvar` can be used to specify the name of the environment
// variable that corresponds to a field. If the `envvar` struct tag is not
// provided, the default is to look for an environment variable with the same
// name as the field. The struct tag `default` can be used to set the default
// value for a field. The default value must be a string, but will be converted
// to match the type of the field as needed. If the `default` struct tag is not
// provided, the corresponding environment variable is required, and Parse will
// return an error if it is not defined. When the `default` struct tag is
// provided, the environment variable is considered optional, and if set, the
// value of the environment variable will override the default value.
//
// Parse will return an UnsetVariableError if a required environment variable
// was not set. It will also return an error if there was a problem converting
// environment variable values to the proper type or setting the fields of v.
func Parse(v interface{}) error {
	// Make sure the type of v is what we expect.
	typ := reflect.TypeOf(v)
	if typ.Kind() != reflect.Ptr || typ.Elem().Kind() != reflect.Struct {
		return fmt.Errorf("envvar: Error in Parse: type must be a pointer to a struct. Got: %T", v)
	}
	structType := typ.Elem()
	val := reflect.ValueOf(v)
	if val.IsNil() {
		return fmt.Errorf("envvar: Error in Parse: argument cannot be nil.")
	}
	structVal := val.Elem()
	// Iterate through the fields of v and set each field.
	for i := 0; i < structType.NumField(); i++ {
		field := structType.Field(i)
		varName := field.Name
		customName := field.Tag.Get("envvar")
		if customName != "" {
			varName = customName
		}
		var varVal string
		defaultVal, foundDefault, err := getStructTag(field, "default")
		if err != nil {
			return err
		}
		envVal, foundEnv := syscall.Getenv(varName)
		if foundEnv {
			// If we found an environment variable corresponding to this field. Use
			// the value of the environment variable. This overrides the default
			// (if any).
			varVal = envVal
		} else {
			if foundDefault {
				// If we did not find an environment variable corresponding to this
				// field, but there is a default value, use the default value.
				varVal = defaultVal
			} else {
				// If we did not find an environment variable corresponding to this
				// field and there is not a default value, we are missing a required
				// environment variable. Return an error.
				return UnsetVariableError{VarName: varName}
			}
		}
		// Set the value of the field.
		if err := setFieldVal(structVal.Field(i), varName, varVal); err != nil {
			return err
		}
	}
	return nil
}
Exemplo n.º 30
0
/*   setup() is tasked with running the setup code from within the namespace,
 * before the target executable is invoked. It is designed to only execute the
 * correct hooks for the features the namespace was created with.
 */
func setup() error {
	// Read in container environment variables.
	nsId, _ := syscall.Getenv("LXNS_ID")

	// Read in container configuration.
	config, e := GetConfig(os.NewFile(3, "-"))
	if e != nil {
		return fmt.Errorf("Failed to import configuration: %v", e)
	}

	// Create a key set to check flags against.
	nsCloneFlags := make(map[string]struct{})
	for _, v := range config.Features {
		nsCloneFlags[v] = empty
	}

	// Do we have networking namespace?
	if _, ok := nsCloneFlags["net"]; ok {
		if e := SetupNetwork(config.NetworkAddr); e != nil {
			return e
		}
	}

	// Do we have mounting namespace?
	if _, ok := nsCloneFlags["ns"]; ok {
		// If we have PID namespace, then mount /proc
		if _, ok := nsCloneFlags["pid"]; ok {
			if e := syscall.Mount("proc", "/proc", "proc",
				syscall.MS_NOEXEC|syscall.MS_NOSUID|syscall.MS_NODEV,
				""); e != nil {
				return fmt.Errorf("Failed to mount proc: %v", e)
			}
		}

		// Change our root filesystem using pivot_root syscall
		if len(config.RootFS) > 0 {
			PivotRoot(config.RootFS)
		}
	}

	// Do we have hostname namespace?
	if _, ok := nsCloneFlags["uts"]; ok {
		hostname := fmt.Sprintf("lxns-%s", nsId)
		if e := syscall.Sethostname([]byte(hostname)); e != nil {
			return e
		}
	}
	return nil
}