// Return the given interface as a YAML byte slice.
func toYaml(i interface{}) []byte {
	data, err := yaml.Marshal(i)
	if err != nil {
		panic(err)
	}
	return data
}

func yamlFn(v interface{}) (string, error) {
	data, err := yaml.Marshal(v)
	if err != nil {
		return "", err
	}
	return string(data), nil
}

func (metadata *RightScriptMetadata) WriteTo(script io.Writer) (n int64, err error) {
	if metadata.Comment == "" {
		metadata.Comment = "#"
	}

	if metadata.Inputs == nil {
		metadata.Inputs = InputMap{}
	}

	c, err := fmt.Fprintf(script, "%s ---\n", metadata.Comment)
	if n += int64(c); err != nil {
		return
	}

	yml, err := yaml.Marshal(metadata)
	scanner := bufio.NewScanner(bytes.NewBuffer(yml))

	for scanner.Scan() {
		c, err = fmt.Fprintf(script, "%s %s\n", metadata.Comment, scanner.Text())
		if n += int64(c); err != nil {
			return
		}
	}
	if err = scanner.Err(); err != nil {
		return
	}

	c, err = fmt.Fprintf(script, "%s ...\n", metadata.Comment)
	if n += int64(c); err != nil {
		return
	}

	return
}

// Execute runs the command
func (c *CommandPush) Execute(b *Build) (State, error) {
	if len(c.cfg.args) != 1 {
		return b.state, fmt.Errorf("PUSH requires exactly one argument")
	}

	if b.state.ImageID == "" {
		return b.state, fmt.Errorf("Cannot PUSH empty image")
	}

	if err := b.client.TagImage(b.state.ImageID, c.cfg.args[0]); err != nil {
		return b.state, err
	}

	image := imagename.NewFromString(c.cfg.args[0])
	artifact := imagename.Artifact{
		Name:      image,
		Pushed:    b.cfg.Push,
		Tag:       image.GetTag(),
		ImageID:   b.state.ImageID,
		BuildTime: time.Now(),
	}

	// push image and add some lines to artifacts
	if b.cfg.Push {
		digest, err := b.client.PushImage(image.String())
		if err != nil {
			return b.state, err
		}
		artifact.Digest = digest
		artifact.Addressable = fmt.Sprintf("%[email protected]%s", image.NameWithRegistry(), digest)
	} else {
		log.Infof("| Don't push. Pass --push flag to actually push to the registry")
	}

	// Publish artifact files
	if b.cfg.ArtifactsPath != "" {
		if err := os.MkdirAll(b.cfg.ArtifactsPath, 0755); err != nil {
			return b.state, fmt.Errorf("Failed to create directory %s for the artifacts, error: %s", b.cfg.ArtifactsPath, err)
		}

		filePath := filepath.Join(b.cfg.ArtifactsPath, artifact.GetFileName())

		artifacts := imagename.Artifacts{
			[]imagename.Artifact{artifact},
		}
		content, err := yaml.Marshal(artifacts)
		if err != nil {
			return b.state, err
		}

		if err := ioutil.WriteFile(filePath, content, 0644); err != nil {
			return b.state, fmt.Errorf("Failed to write artifact file %s, error: %s", filePath, err)
		}

		log.Infof("| Saved artifact file %s", filePath)
		log.Debugf("Artifact properties: %# v", pretty.Formatter(artifact))
	}

	return b.state, nil
}

func yamlFn(args ...interface{}) (result string, err error) {
	var (
		i     = 0
		input interface{}
	)

	if len(args) == 1 {
		input = args[0]
	} else if len(args) == 2 {
		if i, err = interfaceToInt(args[0]); err != nil {
			return "", err
		}
		input = args[1]
	} else {
		return "", fmt.Errorf("yaml helper expects from 1 to 2 arguments, %d given", len(args))
	}

	data, err := yaml.Marshal(input)
	if err != nil {
		return "", err
	}
	result = string(data)

	if i > 0 {
		result = indent(strings.Repeat("  ", i), result)
	}

	return result, nil
}

// CreateContainerOptions returns create configuration eatable by go-dockerclient
func (a *Container) CreateContainerOptions() (*docker.CreateContainerOptions, error) {
	apiConfig := a.Config.GetAPIConfig()

	yamlData, err := yaml.Marshal(a.Config)
	if err != nil {
		return nil, err
	}

	// Copy labels because we want to assign some extra stuff
	labels := map[string]string{}
	for k, v := range apiConfig.Labels {
		labels[k] = v
	}
	labels["rocker-compose-id"] = util.GenerateRandomID()
	labels["rocker-compose-config"] = string(yamlData)

	apiConfig.Labels = labels
	apiConfig.Image = a.Image.String()

	return &docker.CreateContainerOptions{
		Name:       a.Name.String(),
		Config:     apiConfig,
		HostConfig: a.Config.GetAPIHostConfig(),
	}, nil
}

func (c *Config) Dump() (yamlDoc string, err error) {
	defer errs.PassE(&err)
	buf, err := yaml.Marshal(c.ast)
	errs.CheckE(err)
	yamlDoc = string(buf)
	return
}

func TestYamlLink(t *testing.T) {
	assertions := map[string]string{
		"platform.statsd":          "platform.statsd:statsd",
		"platform.statsd:metrics":  "platform.statsd:metrics",
		"/platform.statsd":         "platform.statsd:statsd",
		"/platform.statsd:metrics": "platform.statsd:metrics",
		"statsd":                   "statsd:statsd",
		"statsd:metrics":           "statsd:metrics",
		".statsd":                  "statsd:statsd",
		".statsd:metrics":          "statsd:metrics",
		"":                         "\"\"",
	}

	for inYaml, outYaml := range assertions {
		v := Link{}
		if err := yaml.Unmarshal([]byte(inYaml), &v); err != nil {
			t.Fatal(err)
		}
		data, err := yaml.Marshal(v)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, outYaml, strings.TrimSpace(string(data)))
	}
}

func (s *Supervisor) saveDB() error {
	s.mu.Lock()
	defer s.mu.Unlock()
	data, err := yaml.Marshal(s.programs())
	if err != nil {
		return err
	}
	return ioutil.WriteFile(s.programPath(), data, 0644)
}

func TestImagename_ToYaml(t *testing.T) {
	value := struct {
		Name *ImageName
	}{
		NewFromString("hub/ns/name:1"),
	}

	data, err := yaml.Marshal(value)
	if err != nil {
		t.Fatal(err)
	}

	assert.Equal(t, "name: hub/ns/name:1\n", string(data))
}

func (config *ConfigViper) ShowConfiguration(output io.Writer) error {
	// Check if config file exists
	if _, err := os.Stat(config.ConfigFileUsed()); err != nil {
		return err
	}

	yml, err := yaml.Marshal(config.AllSettings())
	if err != nil {
		return err
	}
	output.Write(yml)

	return nil
}

func (a *yamlTestCases) run(t *testing.T) error {
	for inYaml, outYaml := range a.assertions {
		v := &Container{}
		if err := yaml.Unmarshal([]byte(inYaml), v); err != nil {
			return fmt.Errorf("Failed unmarshal for test %q, error: %s", inYaml, err)
		}
		data, err := yaml.Marshal(v)
		if err != nil {
			return fmt.Errorf("Failed marshal for test %q, error: %s", inYaml, err)
		}
		assert.Equal(t, outYaml, strings.TrimSpace(string(data)))
	}
	return nil
}

func compareYaml(name string, a, b *Container) (bool, error) {
	av := reflect.Indirect(reflect.ValueOf(a)).FieldByName(name)
	bv := reflect.Indirect(reflect.ValueOf(b)).FieldByName(name)

	isSlice := av.Type().Kind() == reflect.Slice
	isMap := av.Type().Kind() == reflect.Map

	// empty values and nil pointer should be considered equal
	if av.IsNil() && !isSlice && !isMap {
		av = reflect.New(av.Type().Elem())
	}
	if bv.IsNil() && !isSlice && !isMap {
		bv = reflect.New(bv.Type().Elem())
	}

	// sort lists which should not consider different order to be a change
	if isSlice && name != "Entrypoint" && name != "Cmd" {
		aSorted := newYamlSortable(av)
		sort.Sort(aSorted)
		av = reflect.ValueOf(aSorted)

		bSorted := newYamlSortable(bv)
		sort.Sort(bSorted)
		bv = reflect.ValueOf(bSorted)
	}

	yml1, err := yaml.Marshal(av.Interface())
	if err != nil {
		return false, err
	}
	yml2, err := yaml.Marshal(bv.Interface())
	if err != nil {
		return false, err
	}

	return string(yml1) == string(yml2), nil
}

func (self *Api) UpdateAuth(token *oauth2.Token) error {
	// Save auth data

	log.WithFields(log.Fields{"Target": self.AuthFile}).Debug("Saving authentication data")

	yml, err := yaml.Marshal(&token)
	if err != nil {
		return err
	}

	err = ioutil.WriteFile(self.AuthFile, yml, 0600)
	if err != nil {
		return err
	}

	return nil
}

// WriteConfig writes config from file to structure
func WriteConfig(config Config, fname string) error {
	yamlConfig := &yamlConfig{}
	yamlConfig.Services = make([]yamlServiceConfig, len(config.Services))
	i := 0
	for k, v := range config.Services {
		ysc := &yamlServiceConfig{}
		ysc.Service = k
		ysc.Api = v.Common.Api
		ysc.Config = v.ServiceSpecific
		yamlConfig.Services[i] = *ysc
		i++
	}

	b, err := yaml.Marshal(yamlConfig)
	if err != nil {
		return err
	}
	return ioutil.WriteFile(fname, b, 0777)
}

func readConf(filename string) (c Configuration, err error) {
	// initial default value
	c.Server.Addr = ":11313" // in memory of 08-31 13:13
	c.Client.ServerURL = "http://localhost:11313"

	data, err := ioutil.ReadFile(filename)
	if err != nil {
		data = []byte("")
	}
	err = yaml.Unmarshal(data, &c)
	if err != nil {
		return
	}
	cfgDir := filepath.Dir(filename)
	if !IsDir(cfgDir) {
		os.MkdirAll(cfgDir, 0755)
	}
	data, _ = yaml.Marshal(c)
	err = ioutil.WriteFile(filename, data, 0644)
	return
}

func TestYamlPortBinding(t *testing.T) {
	assertions := map[string]string{
		"":                      "\"\"",
		"8000":                  "8000/tcp",
		"8125/udp":              "8125/udp",
		"8081:8000":             "8081:8000/tcp",
		"8126:8125/udp":         "8126:8125/udp",
		"0.0.0.0::5959":         "0.0.0.0::5959/tcp",
		"0.0.0.0:8081:80":       "0.0.0.0:8081:80/tcp",
		"0.0.0.0:8126:8125/udp": "0.0.0.0:8126:8125/udp",
	}

	for inYaml, outYaml := range assertions {
		v := PortBinding{}
		if err := yaml.Unmarshal([]byte(inYaml), &v); err != nil {
			t.Fatal(err)
		}
		data, err := yaml.Marshal(v)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, outYaml, strings.TrimSpace(string(data)))
	}
}

// Process processes the code yielding a []byte of the YAML
// representation of the Swagger defintion. The processing rules are
// as follows:
// 1. For each common.Service found, go over its Routes (whatever Routes() method yields)
//    and based on that create the paths and operations.
// 2. For structs, field-level comments are taken from the description value of
//    "romana" structure tag. For example:
//      type Policy struct {
//          Direction string `json:"direction,omitempty" romana:"desc:Direction is one of 'ingress' or egress'."`
//          ...
//      }
func (rd *Swaggerer) Process() ([]byte, error) {
	rd.init()
	rd.swagger.Paths = rd.getPaths()
	json, err := yaml.Marshal(rd.swagger)
	return json, err
}

func (items yamlSortable) Less(i, j int) bool {
	yml1, _ := yaml.Marshal(items[i])
	yml2, _ := yaml.Marshal(items[j])
	return string(yml1) < string(yml2)
}

// Obtain input via STDIN then print out to config file
// Example of config file
// login:
//   default_account: acct1
//   accounts:
//     acct1:
//       id: 67972
//       host: us-3.rightscale.com
//       refresh_token: abc123abc123abc123abc123abc123abc123abc1
//     acct2:
//       id: 60073
//       host: us-4.rightscale.com
//       refresh_token: zxy987zxy987zxy987zxy987xzy987zxy987xzy9
func (config *ConfigViper) SetAccount(name string, setDefault bool, input io.Reader, output io.Writer) error {
	// if the default account isn't set we should set it to the account we are setting
	if !config.IsSet("login.default_account") {
		setDefault = true
	}

	// get the settings and specifically the login settings into a map we can manipulate and marshal to YAML unhindered
	// by the meddling of the Viper
	settings := config.AllSettings()
	loginSettings := settings["login"].(map[interface{}]interface{})

	// set the default account if we want or need to
	if setDefault {
		loginSettings["default_account"] = name
	}

	// get the previous value for the named account if it exists and construct a new account to populate
	oldAccount, ok := config.Accounts[name]
	newAccount := &Account{}

	// prompt for the account ID and use the old value if nothing is entered
	fmt.Fprint(output, "Account ID")
	if ok {
		fmt.Fprintf(output, " (%d)", oldAccount.Id)
	}
	fmt.Fprint(output, ": ")
	fmt.Fscanln(input, &newAccount.Id)
	if ok && newAccount.Id == 0 {
		newAccount.Id = oldAccount.Id
	}

	// prompt for the API endpoint host and use the old value if nothing is entered
	fmt.Fprint(output, "API endpoint host")
	if ok {
		fmt.Fprintf(output, " (%s)", oldAccount.Host)
	}
	fmt.Fprint(output, ": ")
	fmt.Fscanln(input, &newAccount.Host)
	if ok && newAccount.Host == "" {
		newAccount.Host = oldAccount.Host
	}

	// prompt for the refresh token and use the old value if nothing is entered
	fmt.Fprint(output, "Refresh token")
	if ok {
		fmt.Fprintf(output, " (%s)", oldAccount.RefreshToken)
	}
	fmt.Fprint(output, ": ")
	fmt.Fscanln(input, &newAccount.RefreshToken)
	if ok && newAccount.RefreshToken == "" {
		newAccount.RefreshToken = oldAccount.RefreshToken
	}

	// add the new account to the map of accounts overwriting any old value
	accounts := loginSettings["accounts"].(map[interface{}]interface{})
	accounts[name] = newAccount

	// render the settings map as YAML
	yml, err := yaml.Marshal(settings)
	if err != nil {
		return err
	}

	configPath := config.ConfigFileUsed()
	// back up the current config file before writing a new one or if one does not exist, make sure the directory exists
	if err := os.Rename(configPath, configPath+".bak"); err != nil {
		if os.IsNotExist(err) {
			if err := os.MkdirAll(filepath.Dir(configPath), 0700); err != nil {
				return err
			}
		} else {
			return err
		}
	}

	// create a new config file which only the current user can read or write
	configFile, err := os.OpenFile(configPath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
	if err != nil {
		return err
	}
	defer configFile.Close()

	// write the YAML into the config file
	if _, err := configFile.Write(yml); err != nil {
		return err
	}

//.........这里部分代码省略.........