func (c *getCommand) Execute(args []string) error {
context := c.context()
if context == nil {
return fmt.Errorf("cannot get without a context")
}
if c.Typed && c.Document {
return fmt.Errorf("cannot use -d and -t together")
}
patch := make(map[string]interface{})
context.Lock()
transaction := configstate.ContextTransaction(context)
context.Unlock()
for _, key := range c.Positional.Keys {
var value interface{}
err := transaction.Get(c.context().SnapName(), key, &value)
if err == nil {
patch[key] = value
} else if configstate.IsNoOption(err) {
if !c.Typed {
value = ""
}
} else {
return err
}
}
var confToPrint interface{} = patch
if !c.Document && len(c.Positional.Keys) == 1 {
confToPrint = patch[c.Positional.Keys[0]]
}
if c.Typed && confToPrint == nil {
c.printf("null\n")
return nil
}
if s, ok := confToPrint.(string); ok && !c.Typed {
c.printf("%s\n", s)
return nil
}
var bytes []byte
if confToPrint != nil {
var err error
bytes, err = json.MarshalIndent(confToPrint, "", "\t")
if err != nil {
return err
}
}
c.printf("%s\n", string(bytes))
return nil
}
func (s *transactionSuite) TestSetGet(c *C) {
s.state.Lock()
defer s.state.Unlock()
for _, test := range setGetTests {
c.Logf("-----")
s.state.Set("config", map[string]interface{}{})
t := configstate.NewTransaction(s.state)
snap := "core"
for _, op := range test {
c.Logf("%s", op)
switch op.kind() {
case "set":
for k, v := range op.args() {
err := t.Set(snap, k, v)
if op.fails() {
c.Assert(err, ErrorMatches, op.error())
} else {
c.Assert(err, IsNil)
}
}
case "get":
for k, expected := range op.args() {
var obtained interface{}
err := t.Get(snap, k, &obtained)
if op.fails() {
c.Assert(err, ErrorMatches, op.error())
var nothing interface{}
c.Assert(t.GetMaybe(snap, k, ¬hing), ErrorMatches, op.error())
c.Assert(nothing, IsNil)
continue
}
if expected == "-" {
if !configstate.IsNoOption(err) {
c.Fatalf("Expected %q key to not exist, but it has value %v", k, obtained)
}
c.Assert(err, ErrorMatches, fmt.Sprintf("snap %q has no %q configuration option", snap, k))
var nothing interface{}
c.Assert(t.GetMaybe(snap, k, ¬hing), IsNil)
c.Assert(nothing, IsNil)
continue
}
c.Assert(err, IsNil)
c.Assert(obtained, DeepEquals, expected)
obtained = nil
c.Assert(t.GetMaybe(snap, k, &obtained), IsNil)
c.Assert(obtained, DeepEquals, expected)
}
case "commit":
t.Commit()
case "setunder":
var config map[string]map[string]interface{}
s.state.Get("config", &config)
if config == nil {
config = make(map[string]map[string]interface{})
}
if config[snap] == nil {
config[snap] = make(map[string]interface{})
}
for k, v := range op.args() {
if v == "-" {
delete(config[snap], k)
if len(config[snap]) == 0 {
delete(config[snap], snap)
}
} else {
config[snap][k] = v
}
}
s.state.Set("config", config)
case "getunder":
var config map[string]map[string]interface{}
s.state.Get("config", &config)
for k, expected := range op.args() {
obtained, ok := config[snap][k]
if expected == "-" {
if ok {
c.Fatalf("Expected %q key to not exist, but it has value %v", k, obtained)
}
continue
}
c.Assert(obtained, DeepEquals, expected)
}
default:
panic("unknown test op kind: " + op.kind())
}
}
}
}