func (s *interfaceManagerSuite) TestDisconnectTracksConnectionsInState(c *C) {
s.mockIface(c, &interfaces.TestInterface{InterfaceName: "test"})
s.mockSnap(c, consumerYaml)
s.mockSnap(c, producerYaml)
s.state.Lock()
s.state.Set("conns", map[string]interface{}{
"consumer:plug producer:slot": map[string]interface{}{"interface": "test"},
})
s.state.Unlock()
mgr := s.manager(c)
s.state.Lock()
ts, err := ifacestate.Disconnect(s.state, "consumer", "plug", "producer", "slot")
c.Assert(err, IsNil)
change := s.state.NewChange("disconnect", "")
change.AddAll(ts)
s.state.Unlock()
mgr.Ensure()
mgr.Wait()
mgr.Stop()
s.state.Lock()
defer s.state.Unlock()
c.Check(change.Status(), Equals, state.DoneStatus)
var conns map[string]interface{}
err = s.state.Get("conns", &conns)
c.Assert(err, IsNil)
c.Check(conns, DeepEquals, map[string]interface{}{})
}
// changeInterfaces controls the interfaces system.
// Plugs can be connected to and disconnected from slots.
// When enableInternalInterfaceActions is true plugs and slots can also be
// explicitly added and removed.
func changeInterfaces(c *Command, r *http.Request) Response {
var a interfaceAction
decoder := json.NewDecoder(r.Body)
if err := decoder.Decode(&a); err != nil {
return BadRequest("cannot decode request body into an interface action: %v", err)
}
if a.Action == "" {
return BadRequest("interface action not specified")
}
if !c.d.enableInternalInterfaceActions && a.Action != "connect" && a.Action != "disconnect" {
return BadRequest("internal interface actions are disabled")
}
if len(a.Plugs) > 1 || len(a.Slots) > 1 {
return NotImplemented("many-to-many operations are not implemented")
}
if a.Action != "connect" && a.Action != "disconnect" {
return BadRequest("unsupported interface action: %q", a.Action)
}
if len(a.Plugs) == 0 || len(a.Slots) == 0 {
return BadRequest("at least one plug and slot is required")
}
var change *state.Change
var taskset *state.TaskSet
var err error
state := c.d.overlord.State()
state.Lock()
defer state.Unlock()
switch a.Action {
case "connect":
summary := fmt.Sprintf("Connect %s:%s to %s:%s", a.Plugs[0].Snap, a.Plugs[0].Name, a.Slots[0].Snap, a.Slots[0].Name)
change = state.NewChange("connect-snap", summary)
taskset, err = ifacestate.Connect(state, a.Plugs[0].Snap, a.Plugs[0].Name, a.Slots[0].Snap, a.Slots[0].Name)
case "disconnect":
summary := fmt.Sprintf("Disconnect %s:%s from %s:%s", a.Plugs[0].Snap, a.Plugs[0].Name, a.Slots[0].Snap, a.Slots[0].Name)
change = state.NewChange("disconnect-snap", summary)
taskset, err = ifacestate.Disconnect(state, a.Plugs[0].Snap, a.Plugs[0].Name, a.Slots[0].Snap, a.Slots[0].Name)
}
if err == nil {
change.AddAll(taskset)
}
if err != nil {
return BadRequest("%v", err)
}
state.EnsureBefore(0)
return AsyncResponse(nil, &Meta{Change: change.ID()})
}
func (s *interfaceManagerSuite) TestDisconnectTask(c *C) {
s.state.Lock()
defer s.state.Unlock()
ts, err := ifacestate.Disconnect(s.state, "consumer", "plug", "producer", "slot")
c.Assert(err, IsNil)
task := ts.Tasks()[0]
c.Assert(task.Kind(), Equals, "disconnect")
var plug interfaces.PlugRef
err = task.Get("plug", &plug)
c.Assert(err, IsNil)
c.Assert(plug.Snap, Equals, "consumer")
c.Assert(plug.Name, Equals, "plug")
var slot interfaces.SlotRef
err = task.Get("slot", &slot)
c.Assert(err, IsNil)
c.Assert(slot.Snap, Equals, "producer")
c.Assert(slot.Name, Equals, "slot")
}
func (s *interfaceManagerSuite) TestDisconnectSetsUpSecurity(c *C) {
s.mockIface(c, &interfaces.TestInterface{InterfaceName: "test"})
s.mockSnap(c, consumerYaml)
s.mockSnap(c, producerYaml)
s.state.Lock()
s.state.Set("conns", map[string]interface{}{
"consumer:plug producer:slot": map[string]interface{}{"interface": "test"},
})
s.state.Unlock()
mgr := s.manager(c)
s.state.Lock()
ts, err := ifacestate.Disconnect(s.state, "consumer", "plug", "producer", "slot")
c.Assert(err, IsNil)
change := s.state.NewChange("disconnect", "")
change.AddAll(ts)
s.state.Unlock()
mgr.Ensure()
mgr.Wait()
mgr.Stop()
s.state.Lock()
defer s.state.Unlock()
c.Check(change.Status(), Equals, state.DoneStatus)
c.Assert(s.secBackend.SetupCalls, HasLen, 2)
c.Assert(s.secBackend.RemoveCalls, HasLen, 0)
c.Check(s.secBackend.SetupCalls[0].SnapInfo.Name(), Equals, "consumer")
c.Check(s.secBackend.SetupCalls[1].SnapInfo.Name(), Equals, "producer")
c.Check(s.secBackend.SetupCalls[0].DevMode, Equals, false)
c.Check(s.secBackend.SetupCalls[1].DevMode, Equals, false)
}
func (s *interfaceManagerSuite) TestEnsureProcessesDisconnectTask(c *C) {
s.mockIface(c, &interfaces.TestInterface{InterfaceName: "test"})
s.mockSnap(c, consumerYaml)
s.mockSnap(c, producerYaml)
s.state.Lock()
s.state.Set("conns", map[string]interface{}{
"consumer:plug producer:slot": map[string]interface{}{"interface": "test"},
})
s.state.Unlock()
s.state.Lock()
change := s.state.NewChange("kind", "summary")
ts, err := ifacestate.Disconnect(s.state, "consumer", "plug", "producer", "slot")
c.Assert(err, IsNil)
change.AddAll(ts)
s.state.Unlock()
mgr := s.manager(c)
mgr.Ensure()
mgr.Wait()
s.state.Lock()
defer s.state.Unlock()
task := change.Tasks()[0]
c.Check(task.Kind(), Equals, "disconnect")
c.Check(task.Status(), Equals, state.DoneStatus)
c.Check(change.Status(), Equals, state.DoneStatus)
// The connection is gone
repo := mgr.Repository()
plug := repo.Plug("consumer", "plug")
slot := repo.Slot("producer", "slot")
c.Assert(plug.Connections, HasLen, 0)
c.Assert(slot.Connections, HasLen, 0)
}