func getAttributes(keys []string, overwriteAttributes map[string]interface{}) (map[string]interface{}, error) {
	var attributes map[string]interface{}
	var c *api.Client = util.Consul()
	attributes = make(map[string]interface{})

	//	Get attributes from consul KVS
	for _, key := range keys {
		list, _, err := c.KV().List(key, &api.QueryOptions{})
		if err != nil {
			return nil, err
		}

		for _, kv := range list {
			var a map[string]interface{}
			if err := json.Unmarshal(kv.Value, &a); err != nil {
				return nil, err
			}
			if err := mergo.MergeWithOverwrite(&attributes, a); err != nil {
				return nil, errors.New(fmt.Sprintf("Failed to merge attributes(%v)", err))
			}
		}
	}

	//	Overwrite some attributes by specified parameter in task.yml
	if err := mergo.MergeWithOverwrite(&attributes, overwriteAttributes); err != nil {
		return nil, err
	}
	return attributes, nil
}

func loadConfigFile(o *Options) {
	isDefault := false
	configPath := o.ConfigFile
	if o.ConfigFile == "" {
		isDefault = true
		configPath = "./deploy.yaml"
	}

	data, err := ioutil.ReadFile(configPath)
	if err != nil {
		if os.IsNotExist(err) && isDefault {
			return
		}

		panic(err)
	}

	var file ConfigFile
	err = yaml.Unmarshal(data, &file)
	panicIf(err)

	var envCfg Options
	if o.Env != "" {
		var ok bool
		envCfg, ok = file[o.Env]
		if !ok {
			panic("Config for specified env not found")
		}
	}

	defCfg, _ := file["default"]

	panicIf(mergo.MergeWithOverwrite(o, defCfg))
	panicIf(mergo.MergeWithOverwrite(o, envCfg))
}

// Load loads the configuration from a yaml file
func (c *Config) Load(file string) error {
	data, err := ioutil.ReadFile(file)

	if err != nil {
		log.Printf("Unable to ReadConfig File: %s -> %s", file, err.Error())
		return err
	}

	conf := Config{}
	err = yaml.Unmarshal(data, &conf)

	if err != nil {
		log.Printf("Unable to load Config File: %s -> %s", file, err.Error())
		return err
	}

	if err := mergo.MergeWithOverwrite(c, conf); err != nil {
		return err
	}

	c.Env = strings.TrimSpace(c.Env)

	env := strings.ToLower(c.Env)

	if !strings.Contains(env, "dev") && !strings.Contains(env, "development") && !strings.Contains(env, "debug") {
		c.Mode = 1
	}

	return nil
}

func (s *SystemTestSuite) TestSetGetConfigSuccess(c *C) {
	// read current config, to prepare the test config with just ansible changes
	cmdStr := `clusterctl config get --json`
	out, err := s.tbn1.RunCommandWithOutput(cmdStr)
	s.Assert(c, err, IsNil, Commentf("output: %s", out))
	var config map[string]interface{}
	err = json.Unmarshal([]byte(out), &config)
	s.Assert(c, err, IsNil)
	var testConfig map[string]interface{}
	err = json.Unmarshal([]byte(`{
    "ansible": {
        "playbook_location":  "foo"
    }
}`), &testConfig)
	s.Assert(c, err, IsNil)
	err = mergo.MergeWithOverwrite(&config, &testConfig)
	s.Assert(c, err, IsNil)
	configStr, err := json.Marshal(config)
	s.Assert(c, err, IsNil)

	c.Logf("config: %+v", config)
	c.Logf("json: %q", configStr)
	cmdStr = fmt.Sprintf(`clusterctl config set - <<EOF
%s
EOF`, configStr)
	out, err = s.tbn1.RunCommandWithOutput(cmdStr)
	s.Assert(c, err, IsNil, Commentf("output: %s", out))
	cmdStr = `clusterctl config get --json`
	out, err = s.tbn1.RunCommandWithOutput(cmdStr)
	s.Assert(c, err, IsNil, Commentf("output: %s", out))
	exptdOut := `.*"playbook_location":.*"foo".*`
	s.assertMatch(c, exptdOut, out)
}

func (p *Player) AddDebt(d Debt) error {
	newDebt := new(Debt)
	if err := mergo.MergeWithOverwrite(newDebt, d); err != nil {
		return errors.New(err.Error() + " - Could not set Debt data")
	}
	newDebt.UUID, _ = uuid.V4()
	if d.Created.IsZero() {
		newDebt.Created = time.Now()
	} else {
		newDebt.Created = d.Created
	}
	if !d.Settled.IsZero() {
		newDebt.Settled = d.Settled
	}
	newDebt.Debitor = p.UUID
	p.Debts = append(p.Debts, *newDebt)
	err := storage.Store(p)
	if err != nil {
		return errors.New("Could not add debt")
	}
	eventqueue.Publish(utils.CKPTEvent{
		Type:         utils.PLAYER_EVENT,
		RestrictedTo: []uuid.UUID{p.UUID},
		Subject:      "Gjeld registrert",
		Message:      "Det er registrert et nytt gjeldskrav mot deg på ckpt.no!"})
	return nil
}

func (p *Player) SetVotes(v Votes) error {
	if err := mergo.MergeWithOverwrite(&p.Votes, v); err != nil {
		return errors.New(err.Error() + " - Could not set Votes data")
	}
	err := storage.Store(p)
	if err != nil {
		return errors.New("Could not set votes")
	}
	return nil
}

func (l *Location) UpdateProfile(lp Profile) error {
	if err := mergo.MergeWithOverwrite(&l.Profile, lp); err != nil {
		return errors.New(err.Error() + " - Could not update location profile")
	}
	err := storage.Store(l)
	if err != nil {
		return errors.New(err.Error() + " - Could not store updated location profile")
	}
	return nil
}

func (c *Catering) UpdateInfo(ci Info) error {
	if err := mergo.MergeWithOverwrite(&c.Info, ci); err != nil {
		return errors.New(err.Error() + " - Could not update catering info")
	}
	err := storage.Store(c)
	if err != nil {
		return errors.New(err.Error() + " - Could not store updated catering info")
	}
	return nil
}

// Create a Catering
func NewCatering(tournament uuid.UUID, ci Info) (*Catering, error) {
	c := new(Catering)
	c.UUID, _ = uuid.V4()
	c.Tournament = tournament
	if err := mergo.MergeWithOverwrite(&c.Info, ci); err != nil {
		return nil, errors.New(err.Error() + " - Could not set initial catering info")
	}
	if err := storage.Store(c); err != nil {
		return nil, errors.New(err.Error() + " - Could not write catering to storage")
	}
	return c, nil
}

// Create a Location
func NewLocation(host uuid.UUID, lp Profile) (*Location, error) {
	l := new(Location)
	l.UUID, _ = uuid.V4()
	l.Active = true
	l.Host = host
	if err := mergo.MergeWithOverwrite(&l.Profile, lp); err != nil {
		return nil, errors.New(err.Error() + " - Could not set initial location profile")
	}
	if err := storage.Store(l); err != nil {
		return nil, errors.New(err.Error() + " - Could not write location to storage")
	}
	return l, nil
}

// Load loads the configuration from a yaml file
func (c *BuildConfig) Load(file string) error {
	data, err := ioutil.ReadFile(file)

	if err != nil {
		log.Printf("Unable to ReadConfig File: %s -> %s", file, err.Error())
		return err
	}

	conf := BuildConfig{}
	err = yaml.Unmarshal(data, &conf)

	if err != nil {
		log.Printf("Unable to load Config File: %s -> %s", file, err.Error())
		return err
	}

	if conf.Package == "" {
		return errors.New("package option can not be empty, provide the project package name please")
	}

	if err := mergo.MergeWithOverwrite(c, conf); err != nil {
		return err
	}

	if mano, err := strconv.ParseBool(c.UseMain); err == nil {
		c.GoMain = mano
	}

	if vbo, err := strconv.ParseBool(c.Client.Verbose); err == nil {
		c.Client.UseVerbose = vbo
	}

	if doge, err := strconv.ParseBool(c.DoGoGet); err == nil {
		c.Goget = doge
	}

	c.ClientPackage = filepath.Join(c.Package, "client")

	if strings.Contains(c.ClientPackage, `\`) {
		c.ClientPackage = filepath.ToSlash(c.ClientPackage)
	}

	env := strings.ToLower(c.Env)

	if !strings.Contains(env, "dev") && !strings.Contains(env, "development") && !strings.Contains(env, "debug") {
		c.Mode = 1
	}

	return nil
}

// Shell creates an interactive Docker session to the specified service
// starting it if not currently running
func (c *DockerCompose) Shell(config parity.ShellConfig) (err error) {
	log.Stage("Interactive Shell")
	log.Debug("Compose - starting docker compose services")

	mergedConfig := *parity.DEFAULT_INTERACTIVE_SHELL_OPTIONS
	mergo.MergeWithOverwrite(&mergedConfig, &config)
	// Check if services running

	// TODO: if running, attach to running container
	// if NOT running, start services and attach
	if c.project != nil {
		log.Step("Starting compose services")

		injectDisplayEnvironmentVariables(c.project)
	}

	container := fmt.Sprintf("parity-%s_%s_1", c.pluginConfig.ProjectNameSafe, mergedConfig.Service)

	client := utils.DockerClient()

	createExecOptions := dockerclient.CreateExecOptions{
		AttachStdin:  true,
		AttachStdout: true,
		AttachStderr: true,
		Tty:          true,
		Cmd:          mergedConfig.Command,
		User:         mergedConfig.User,
		Container:    container,
	}

	startExecOptions := dockerclient.StartExecOptions{
		Detach:       false,
		Tty:          true,
		InputStream:  os.Stdin,
		OutputStream: os.Stdout,
		ErrorStream:  os.Stderr,
		RawTerminal:  true,
	}

	log.Step("Attaching to container '%s'", container)
	if id, err := client.CreateExec(createExecOptions); err == nil {
		client.StartExec(id.ID, startExecOptions)
	} else {
		log.Error("error: %v", err.Error())
	}

	log.Debug("Docker Compose Run() finished")
	return err
}

func (c *Config) ApplyDefaults() {
	// config := defaultConfig

	setDebug := !c.Debug
	var shouldDebug bool
	if setDebug {
		shouldDebug = c.Debug
	}

	mergo.MergeWithOverwrite(c, defaultConfig)

	if setDebug {
		c.Debug = shouldDebug
	}
}

func (c *NewsItem) UpdateNewsItem(ci NewsItem) error {
	d := new(NewsItem)
	*d = *c
	if err := mergo.MergeWithOverwrite(c, ci); err != nil {
		return errors.New(err.Error() + " - Could not update NewsItem info")
	}
	c.UUID = d.UUID
	c.Author = d.Author
	c.Created = d.Created
	c.Tag = d.Tag
	err := storage.Store(c)
	if err != nil {
		return errors.New(err.Error() + " - Could not store updated NewsItem info")
	}
	return nil
}

// Create a NewsItem
func NewNewsItem(itemdata NewsItem, author uuid.UUID) (*NewsItem, error) {
	c := new(NewsItem)
	if err := mergo.MergeWithOverwrite(c, itemdata); err != nil {
		return nil, errors.New(err.Error() + " - Could not set initial NewsItem data")
	}
	c.UUID, _ = uuid.V4()
	c.Author = author
	c.Created = time.Now()
	if err := storage.Store(c); err != nil {
		return nil, errors.New(err.Error() + " - Could not write NewsItem to storage")
	}
	eventqueue.Publish(utils.CKPTEvent{
		Type:    utils.NEWS_EVENT,
		Subject: "Nytt bidrag lagt ut",
		Message: "Det er lagt ut et nytt bidrag på ckpt.no!"})
	return c, nil
}

// Create a Tournament
func NewTournament(tdata Info) (*Tournament, error) {
	if err := validateTournamentInfo(tdata); err != nil {
		return nil, errors.New(err.Error() + " - Could not create tournament")
	}

	t := new(Tournament)
	t.UUID, _ = uuid.V4()
	if err := mergo.MergeWithOverwrite(&t.Info, tdata); err != nil {
		return nil, errors.New(err.Error() + " - Could not set initial tournament data")
	}
	// Merge seems to not handle time.Time for some reason, thus fixup
	fixupTournamentInfo(&t.Info, tdata)
	if err := storage.Store(t); err != nil {
		return nil, errors.New(err.Error() + " - Could not write tournament to storage")
	}
	return t, nil
}

// LoadJSON loads the configuration from a yaml file
func (t *TemplateConfig) LoadJSON(file string) error {
	data, err := ioutil.ReadFile(file)

	if err != nil {
		log.Printf("Unable to ReadConfig File: %s -> %s", file, err.Error())
		return err
	}

	conf := TemplateConfig{}
	err = json.Unmarshal(data, &conf)

	if err != nil {
		log.Printf("Unable to load Config File: %s -> %s", file, err.Error())
		return err
	}

	return mergo.MergeWithOverwrite(t, conf)
}

// Load a single JSON file, and merge it into the specified Config
func LoadJSONFile(filePath string, conf Config) error {
	defer Track("LoadJSONFile", Now(), debugOut)

	buf, err := ioutil.ReadFile(filePath)
	if err != nil {
		debugOut.Printf("Error reading config file '%s': %s\n", filePath, err)
		return err
	}

	newConf, err := JsonToConfig(buf)
	if err != nil {
		debugOut.Printf("Error parsing JSON in config file '%s': %s\n", filePath, err)
		return err
	}

	err = mergo.MergeWithOverwrite(&conf, newConf)
	return nil
}

// Load loads the configuration from a yaml file
func (c *ClientConfig) Load(file string) error {
	data, err := ioutil.ReadFile(file)

	if err != nil {
		log.Printf("Unable to ReadConfig File: %s -> %s", file, err.Error())
		return err
	}

	conf := ClientConfig{}
	err = yaml.Unmarshal(data, &conf)

	if err != nil {
		log.Printf("Unable to load Config File: %s -> %s", file, err.Error())
		return err
	}

	return mergo.MergeWithOverwrite(c, conf)
}

// Attach attaches to the specified service in the running container
func (c *DockerCompose) Attach(config parity.ShellConfig) (err error) {
	log.Stage("Interactive Shell")
	log.Debug("Compose - starting docker compose services")

	mergedConfig := *parity.DEFAULT_INTERACTIVE_SHELL_OPTIONS
	mergo.MergeWithOverwrite(&mergedConfig, &config)

	client := utils.DockerClient()
	container := fmt.Sprintf("parity-%s_%s_1", c.pluginConfig.ProjectNameSafe, mergedConfig.Service)

	opts := dockerclient.AttachToContainerOptions{
		Stdin:        true,
		Stdout:       true,
		Stderr:       true,
		InputStream:  os.Stdin,
		OutputStream: os.Stdout,
		ErrorStream:  os.Stderr,
		RawTerminal:  true,
		Container:    container,
		Stream:       true,
		Logs:         true,
	}

	if c.project.Configs[config.Service] == nil {
		return fmt.Errorf("Service %s does not exist", config.Service)
	}

	log.Step("Attaching to container '%s'", container)
	if err := client.AttachToContainer(opts); err == nil {
		err = c.project.Up(config.Service)
		if err != nil {
			log.Error("error: %s", err.Error())
			return err
		}
	} else {
		return err
	}

	_, err = client.WaitContainer(container)
	log.Error("wc error: %s", err.Error())

	log.Debug("Docker Compose Run() finished")
	return err
}