func (m b64yaml) encode() string {
data, err := goyaml.Marshal(m)
if err != nil {
panic(err)
}
return base64.StdEncoding.EncodeToString(data)
}
func (s *migrateAgentEnvUUIDSuite) removeEnvUUIDFromAgentConfig(c *gc.C) {
// Read the file in as simple map[string]interface{} and delete
// the element, and write it back out again.
// First step, read the file contents.
filename := agent.ConfigPath(agent.DefaultDataDir, s.machine.Tag())
data, err := ioutil.ReadFile(filename)
c.Assert(err, jc.ErrorIsNil)
c.Logf("Data in:\n\n%s\n", data)
// Parse it into the map.
var content map[string]interface{}
err = goyaml.Unmarshal(data, &content)
c.Assert(err, jc.ErrorIsNil)
// Remove the environment value, and marshal back into bytes.
delete(content, "environment")
data, err = goyaml.Marshal(content)
c.Assert(err, jc.ErrorIsNil)
// Write the yaml back out remembering to add the format prefix.
data = append([]byte("# format 1.18\n"), data...)
c.Logf("Data out:\n\n%s\n", data)
err = ioutil.WriteFile(filename, data, 0644)
c.Assert(err, jc.ErrorIsNil)
// Reset test attributes.
cfg, err := agent.ReadConfig(filename)
c.Assert(err, jc.ErrorIsNil)
s.ctx.realAgentConfig = cfg
}
func (formatter_1_18) marshal(config *configInternal) ([]byte, error) {
format := &format_1_18Serialization{
Tag: config.tag.String(),
DataDir: config.dataDir,
LogDir: config.logDir,
Jobs: config.jobs,
UpgradedToVersion: &config.upgradedToVersion,
Nonce: config.nonce,
CACert: string(config.caCert),
OldPassword: config.oldPassword,
Values: config.values,
PreferIPv6: config.preferIPv6,
}
if config.servingInfo != nil {
format.StateServerCert = config.servingInfo.Cert
format.StateServerKey = config.servingInfo.PrivateKey
format.APIPort = config.servingInfo.APIPort
format.StatePort = config.servingInfo.StatePort
format.SharedSecret = config.servingInfo.SharedSecret
format.SystemIdentity = config.servingInfo.SystemIdentity
}
if config.stateDetails != nil {
format.StateAddresses = config.stateDetails.addresses
format.StatePassword = config.stateDetails.password
}
if config.apiDetails != nil {
format.APIAddresses = config.apiDetails.addresses
format.APIPassword = config.apiDetails.password
}
return goyaml.Marshal(format)
}
// SaveState writes the given state to the given storage.
func SaveState(storage storage.StorageWriter, state *BootstrapState) error {
data, err := goyaml.Marshal(state)
if err != nil {
return err
}
return putState(storage, data)
}
// marshalConfig marshals the specified configI interface into yaml
// bytes.
func marshalConfig(configI interface{}, t *testing.T) []byte {
bytes, err := yaml.Marshal(configI)
if err != nil {
t.Fatal(err)
}
return bytes
}
// runSetUser invokes the REST API with POST action and username as
// path. Prompts for the password twice on stdin.
// TODO(marc): once we have more fields in the user config, we will need
// to allow changing just some of them (eg: change email, but leave password).
func runSetUser(cmd *cobra.Command, args []string) {
if len(args) != 1 {
cmd.Usage()
return
}
hashed, err := security.PromptForPasswordAndHash()
if err != nil {
log.Error(err)
return
}
// Build a UserConfig object. RunSetUser expects Yaml.
// TODO(marc): re-work admin client library to take other encodings.
pb := &proto.UserConfig{HashedPassword: hashed}
contents, err := yaml.Marshal(pb)
if err != nil {
log.Error(err)
return
}
admin := client.NewAdminClient(&Context.Context, Context.Addr, client.User)
if err := admin.SetYAML(args[0], string(contents)); err != nil {
log.Error(err)
return
}
fmt.Printf("Wrote user config for %q\n", args[0])
}
func renameRelation(c *gc.C, charmPath, oldName, newName string) {
path := filepath.Join(charmPath, "metadata.yaml")
f, err := os.Open(path)
c.Assert(err, jc.ErrorIsNil)
defer f.Close()
meta, err := corecharm.ReadMeta(f)
c.Assert(err, jc.ErrorIsNil)
replace := func(what map[string]corecharm.Relation) bool {
for relName, relation := range what {
if relName == oldName {
what[newName] = relation
delete(what, oldName)
return true
}
}
return false
}
replaced := replace(meta.Provides) || replace(meta.Requires) || replace(meta.Peers)
c.Assert(replaced, gc.Equals, true, gc.Commentf("charm %q does not implement relation %q", charmPath, oldName))
newmeta, err := goyaml.Marshal(meta)
c.Assert(err, jc.ErrorIsNil)
ioutil.WriteFile(path, newmeta, 0644)
f, err = os.Open(path)
c.Assert(err, jc.ErrorIsNil)
defer f.Close()
_, err = corecharm.ReadMeta(f)
c.Assert(err, jc.ErrorIsNil)
}
func (s *cmdSystemSuite) TestSystemLoginCommand(c *gc.C) {
user := s.Factory.MakeUser(c, &factory.UserParams{
NoEnvUser: true,
Password: "******",
})
apiInfo := s.APIInfo(c)
serverFile := envcmd.ServerFile{
Addresses: apiInfo.Addrs,
CACert: apiInfo.CACert,
Username: user.Name(),
Password: "******",
}
serverFilePath := filepath.Join(c.MkDir(), "server.yaml")
content, err := goyaml.Marshal(serverFile)
c.Assert(err, jc.ErrorIsNil)
err = ioutil.WriteFile(serverFilePath, []byte(content), 0644)
c.Assert(err, jc.ErrorIsNil)
s.run(c, "login", "--server", serverFilePath, "just-a-system")
// Make sure that the saved server details are sufficient to connect
// to the api server.
api, err := juju.NewAPIFromName("just-a-system")
c.Assert(err, jc.ErrorIsNil)
api.Close()
}
func (s *GetSuite) TestGetConfig(c *gc.C) {
sch := s.AddTestingCharm(c, "dummy")
svc := s.AddTestingService(c, "dummy-service", sch)
err := svc.UpdateConfigSettings(charm.Settings{"title": "Nearly There"})
c.Assert(err, jc.ErrorIsNil)
for _, t := range getTests {
ctx := coretesting.Context(c)
code := cmd.Main(envcmd.Wrap(&GetCommand{}), ctx, []string{t.service})
c.Check(code, gc.Equals, 0)
c.Assert(ctx.Stderr.(*bytes.Buffer).String(), gc.Equals, "")
// round trip via goyaml to avoid being sucked into a quagmire of
// map[interface{}]interface{} vs map[string]interface{}. This is
// also required if we add json support to this command.
buf, err := goyaml.Marshal(t.expected)
c.Assert(err, jc.ErrorIsNil)
expected := make(map[string]interface{})
err = goyaml.Unmarshal(buf, &expected)
c.Assert(err, jc.ErrorIsNil)
actual := make(map[string]interface{})
err = goyaml.Unmarshal(ctx.Stdout.(*bytes.Buffer).Bytes(), &actual)
c.Assert(err, jc.ErrorIsNil)
c.Assert(actual, gc.DeepEquals, expected)
}
}
func (yh YamlHacker) Reader() io.Reader {
data, err := goyaml.Marshal(yh)
if err != nil {
panic(err)
}
return bytes.NewBuffer(data)
}
func base64yaml(m *config.Config) string {
data, err := goyaml.Marshal(m.AllAttrs())
if err != nil {
// can't happen, these values have been validated a number of times
panic(err)
}
return base64.StdEncoding.EncodeToString(data)
}
func writeCacheFile(filename string, content CacheFile) error {
data, err := goyaml.Marshal(content)
if err != nil {
return errors.Annotate(err, "cannot marshal cache file")
}
err = ioutil.WriteFile(filename, data, 0600)
return errors.Annotate(err, "cannot write file")
}
// Example_acctContentTypes verifies that the Accept header can be used
// to control the format of the response and the Content-Type header
// can be used to specify the format of the request.
func Example_acctContentTypes() {
_, stopper := startAdminServer()
defer stopper.Stop()
config := &proto.AcctConfig{}
err := yaml.Unmarshal([]byte(testAcctConfig), config)
if err != nil {
fmt.Println(err)
}
testCases := []struct {
contentType, accept string
}{
{util.JSONContentType, util.JSONContentType},
{util.YAMLContentType, util.JSONContentType},
{util.JSONContentType, util.YAMLContentType},
{util.YAMLContentType, util.YAMLContentType},
}
for i, test := range testCases {
key := fmt.Sprintf("/test%d", i)
var body []byte
if test.contentType == util.JSONContentType {
if body, err = json.MarshalIndent(config, "", " "); err != nil {
fmt.Println(err)
}
} else {
if body, err = yaml.Marshal(config); err != nil {
fmt.Println(err)
}
}
req, err := http.NewRequest("POST", fmt.Sprintf("%s://%s%s%s", testContext.RequestScheme(), testContext.Addr,
acctPathPrefix, key), bytes.NewReader(body))
req.Header.Add(util.ContentTypeHeader, test.contentType)
if _, err = sendAdminRequest(testContext, req); err != nil {
fmt.Println(err)
}
req, err = http.NewRequest("GET", fmt.Sprintf("%s://%s%s%s", testContext.RequestScheme(), testContext.Addr,
acctPathPrefix, key), nil)
req.Header.Add(util.AcceptHeader, test.accept)
if body, err = sendAdminRequest(testContext, req); err != nil {
fmt.Println(err)
}
fmt.Println(string(body))
}
// Output:
// {
// "cluster_id": "test"
// }
// {
// "cluster_id": "test"
// }
// cluster_id: test
//
// cluster_id: test
}
func encodeArgs(hooks []string) []byte {
// Marshal to YAML, then encode in base64 to avoid shell escapes.
yamlArgs, err := goyaml.Marshal(hookArgs{Hooks: hooks})
if err != nil {
// This should not happen: we're in full control.
panic(err)
}
return yamlArgs
}
// Encode - Encodes an action into a writer.
func (e *Encoder) Encode(a *action.Action) (err error) {
list := formatAction(a)
body, err := yaml2.Marshal(list)
if err != nil {
return
}
_, err = e.Writer.Write(body)
return
}
// Get retrieves the zone configuration for the specified key. If the
// key is empty, all zone configurations are returned. Otherwise, the
// leading "/" path delimiter is stripped and the zone configuration
// matching the remainder is retrieved. Note that this will retrieve
// the default zone config if "key" is equal to "/", and will list all
// configs if "key" is equal to "". The body result contains
// JSON-formatted output for a listing of keys and YAML-formatted
// output for retrieval of a zone config.
func (zh *zoneHandler) Get(path string, r *http.Request) (body []byte, contentType string, err error) {
// Scan all zones if the key is empty.
if len(path) == 0 {
sr := <-zh.kvDB.Scan(&storage.ScanRequest{
RequestHeader: storage.RequestHeader{
Key: engine.KeyConfigZonePrefix,
EndKey: engine.PrefixEndKey(engine.KeyConfigZonePrefix),
User: storage.UserRoot,
},
MaxResults: maxGetResults,
})
if sr.Error != nil {
err = sr.Error
return
}
if len(sr.Rows) == maxGetResults {
glog.Warningf("retrieved maximum number of results (%d); some may be missing", maxGetResults)
}
var prefixes []string
for _, kv := range sr.Rows {
trimmed := bytes.TrimPrefix(kv.Key, engine.KeyConfigZonePrefix)
prefixes = append(prefixes, url.QueryEscape(string(trimmed)))
}
// JSON-encode the prefixes array.
contentType = "application/json"
if body, err = json.Marshal(prefixes); err != nil {
err = util.Errorf("unable to format zone configurations: %v", err)
}
} else {
zoneKey := engine.MakeKey(engine.KeyConfigZonePrefix, engine.Key(path[1:]))
var ok bool
config := &storage.ZoneConfig{}
if ok, _, err = kv.GetI(zh.kvDB, zoneKey, config); err != nil {
return
}
// On get, if there's no zone config for the requested prefix,
// return a not found error.
if !ok {
err = util.Errorf("no config found for key prefix %q", path)
return
}
var out []byte
if out, err = yaml.Marshal(config); err != nil {
err = util.Errorf("unable to marshal zone config %+v to yaml: %v", config, err)
return
}
if !utf8.ValidString(string(out)) {
err = util.Errorf("config contents not valid utf8: %q", out)
return
}
contentType = "text/yaml"
body = out
}
return
}
func (suite *StateSuite) setUpSavedState(c *gc.C, dataDir string) common.BootstrapState {
state := common.BootstrapState{
StateInstances: []instance.Id{instance.Id("an-instance-id")},
}
content, err := goyaml.Marshal(state)
c.Assert(err, jc.ErrorIsNil)
err = ioutil.WriteFile(filepath.Join(dataDir, common.StateFile), []byte(content), 0644)
c.Assert(err, jc.ErrorIsNil)
return state
}
// zoneProtoToYAMLString takes a marshalled proto and returns
// its yaml representation.
func zoneProtoToYAMLString(val string) (string, error) {
var zone config.ZoneConfig
if err := gogoproto.Unmarshal([]byte(val), &zone); err != nil {
return "", err
}
ret, err := yaml.Marshal(zone)
if err != nil {
return "", err
}
return string(ret), nil
}
func (*utilSuite) TestMachineInfoCloudinitRunCmd(c *gc.C) {
hostname := "hostname"
info := machineInfo{hostname}
filename := "/var/lib/juju/MAASmachine.txt"
script, err := info.cloudinitRunCmd("quantal")
c.Assert(err, gc.IsNil)
yaml, err := goyaml.Marshal(info)
c.Assert(err, gc.IsNil)
expected := fmt.Sprintf("mkdir -p '%s'\ninstall -m 755 /dev/null '%s'\nprintf '%%s\\n' ''\"'\"'%s'\"'\"'' > '%s'", environs.DataDir, filename, yaml, filename)
c.Check(script, gc.Equals, expected)
}
// ExampleAcctContentTypes verifies that the Accept header can be used
// to control the format of the response and the Content-Type header
// can be used to specify the format of the request.
func ExampleAcctContentTypes() {
httpServer := startAdminServer()
defer httpServer.Close()
config := &proto.AcctConfig{}
err := yaml.Unmarshal([]byte(testAcctConfig), config)
if err != nil {
fmt.Println(err)
}
testCases := []struct {
contentType, accept string
}{
{"application/json", "application/json"},
{"text/yaml", "application/json"},
{"application/json", "text/yaml"},
{"text/yaml", "text/yaml"},
}
for i, test := range testCases {
key := fmt.Sprintf("/test%d", i)
var body []byte
if test.contentType == "application/json" {
if body, err = json.MarshalIndent(config, "", " "); err != nil {
fmt.Println(err)
}
} else {
if body, err = yaml.Marshal(config); err != nil {
fmt.Println(err)
}
}
req, err := http.NewRequest("POST", fmt.Sprintf("%s://%s%s%s", adminScheme, testContext.Addr, acctPathPrefix, key), bytes.NewReader(body))
req.Header.Add("Content-Type", test.contentType)
if _, err = sendAdminRequest(req); err != nil {
fmt.Println(err)
}
req, err = http.NewRequest("GET", fmt.Sprintf("%s://%s%s%s", adminScheme, testContext.Addr, acctPathPrefix, key), nil)
req.Header.Add("Accept", test.accept)
if body, err = sendAdminRequest(req); err != nil {
fmt.Println(err)
}
fmt.Println(string(body))
}
// Output:
// {
// "cluster_id": "test"
// }
// {
// "cluster_id": "test"
// }
// cluster_id: test
//
// cluster_id: test
}
func (s *ConstraintsSuite) TestRoundtripYaml(c *gc.C) {
for _, t := range constraintsRoundtripTests {
c.Logf("test %s", t.Name)
data, err := goyaml.Marshal(t.Value)
c.Assert(err, jc.ErrorIsNil)
var cons constraints.Value
err = goyaml.Unmarshal(data, &cons)
c.Check(err, jc.ErrorIsNil)
c.Check(cons, jc.DeepEquals, t.Value)
}
}
// Write strings to the target
func (l *YamlLangWriter) WriteTo(str map[string]interface{}, target io.Writer) (err error) {
w := bufio.NewWriter(target)
d := []byte{}
d, err = yaml.Marshal(&str)
if err != nil {
return
}
w.Write(d)
w.Flush()
return
}
func (*utilSuite) TestMachineInfoCloudinitRunCmd(c *gc.C) {
hostname := "hostname"
info := machineInfo{hostname}
filename := "/var/lib/juju/MAASmachine.txt"
dataDir, err := paths.DataDir("quantal")
c.Assert(err, jc.ErrorIsNil)
cloudcfg, err := cloudinit.New("quantal")
c.Assert(err, jc.ErrorIsNil)
script, err := info.cloudinitRunCmd(cloudcfg)
c.Assert(err, jc.ErrorIsNil)
yaml, err := goyaml.Marshal(info)
c.Assert(err, jc.ErrorIsNil)
expected := fmt.Sprintf("mkdir -p '%s'\ncat > '%s' << 'EOF'\n'%s'\nEOF\nchmod 0755 '%s'", dataDir, filename, yaml, filename)
c.Check(script, gc.Equals, expected)
}
// FormatYaml marshals value to a yaml-formatted []byte, unless value is nil.
func FormatYaml(value interface{}) ([]byte, error) {
if value == nil {
return nil, nil
}
result, err := goyaml.Marshal(value)
if err != nil {
return nil, err
}
for i := len(result) - 1; i > 0; i-- {
if result[i] != '\n' {
break
}
result = result[:i]
}
return result, nil
}
func (s *JujuConnSuite) writeSampleConfig(c *gc.C, path string) {
if s.DummyConfig == nil {
s.DummyConfig = dummy.SampleConfig()
}
attrs := s.DummyConfig.Merge(testing.Attrs{
"admin-secret": AdminSecret,
"agent-version": version.Current.Number.String(),
}).Delete("name")
whole := map[string]interface{}{
"environments": map[string]interface{}{
"dummyenv": attrs,
},
}
data, err := goyaml.Marshal(whole)
c.Assert(err, jc.ErrorIsNil)
s.WriteConfig(string(data))
}
func (suite *StateSuite) TestSaveStateWritesStateFile(c *gc.C) {
stor := suite.newStorage(c)
state := common.BootstrapState{
StateInstances: []instance.Id{instance.Id("an-instance-id")},
}
marshaledState, err := goyaml.Marshal(state)
c.Assert(err, jc.ErrorIsNil)
err = common.SaveState(stor, &state)
c.Assert(err, jc.ErrorIsNil)
loadedState, err := storage.Get(stor, common.StateFile)
c.Assert(err, jc.ErrorIsNil)
content, err := ioutil.ReadAll(loadedState)
c.Assert(err, jc.ErrorIsNil)
c.Check(content, gc.DeepEquals, marshaledState)
}
// cloudinitRunCmd returns the shell command that, when run, will create the
// "machine info" file containing the hostname of a machine.
// That command is destined to be used by cloudinit.
func (info *machineInfo) cloudinitRunCmd(cloudcfg cloudinit.CloudConfig) (string, error) {
dataDir, err := paths.DataDir(cloudcfg.GetSeries())
if err != nil {
return "", errors.Trace(err)
}
yaml, err := goyaml.Marshal(info)
if err != nil {
return "", errors.Trace(err)
}
renderer := cloudcfg.ShellRenderer()
fileName := renderer.Join(renderer.FromSlash(dataDir), "MAASmachine.txt")
script := renderer.MkdirAll(dataDir)
contents := renderer.Quote(string(yaml))
script = append(script, renderer.WriteFile(fileName, []byte(contents))...)
script = append(script, renderer.Chmod(fileName, 0755)...)
return strings.Join(script, "\n"), nil
}
// WriteYaml marshals obj as yaml and then writes it to a file, atomically,
// by first writing a sibling with the suffix ".preparing" and then moving
// the sibling to the real path.
func WriteYaml(path string, obj interface{}) error {
data, err := goyaml.Marshal(obj)
if err != nil {
return err
}
prep := path + ".preparing"
f, err := os.OpenFile(prep, os.O_WRONLY|os.O_CREATE|os.O_SYNC, 0644)
if err != nil {
return err
}
_, err = f.Write(data)
// Explicitly close the file before moving it. This is needed on Windows
// where the OS will not allow us to move a file that still has an open file handle
f.Close()
if err != nil {
return err
}
return ReplaceFile(prep, path)
}
// cloudinitRunCmd returns the shell command that, when run, will create the
// "machine info" file containing the hostname of a machine.
// That command is destined to be used by cloudinit.
func (info *machineInfo) cloudinitRunCmd(series string) (string, error) {
dataDir, err := paths.DataDir(series)
if err != nil {
return "", err
}
renderer, err := cloudinit.NewRenderer(series)
if err != nil {
return "", err
}
yaml, err := goyaml.Marshal(info)
if err != nil {
return "", err
}
fileName := renderer.PathJoin(renderer.FromSlash(dataDir), "MAASmachine.txt")
script := renderer.Mkdir(dataDir)
contents := utils.ShQuote(string(yaml))
script = append(script, renderer.WriteFile(fileName, contents, 0755)...)
return strings.Join(script, "\n"), nil
}
// runSetUser invokes the REST API with POST action and username as
// path. Prompts for the password twice on stdin.
// TODO(marc): once we have more fields in the user config, we will need
// to allow changing just some of them (eg: change email, but leave password).
func runSetUser(cmd *cobra.Command, args []string) {
if len(args) != 1 {
cmd.Usage()
return
}
hashed, err := security.PromptForPasswordAndHash()
if err != nil {
log.Error(err)
return
}
// Build a UserConfig object. RunSetUser expects Yaml.
// TODO(marc): re-work admin client library to take other encodings.
pb := &proto.UserConfig{HashedPassword: hashed}
contents, err := yaml.Marshal(pb)
if err != nil {
log.Error(err)
return
}
server.RunSetUser(Context, args[0], contents)
}
