// 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, user *auth.UserState) 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 summary string
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)
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)
taskset, err = ifacestate.Disconnect(state, a.Plugs[0].Snap, a.Plugs[0].Name, a.Slots[0].Snap, a.Slots[0].Name)
}
if err != nil {
return BadRequest("%v", err)
}
change := state.NewChange(a.Action+"-snap", summary)
change.Set("snap-names", []string{a.Plugs[0].Snap, a.Slots[0].Snap})
change.AddAll(taskset)
state.EnsureBefore(0)
return AsyncResponse(nil, &Meta{Change: change.ID()})
}
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)
ts.Tasks()[0].Set("snap-setup", &snapstate.SnapSetup{
SideInfo: &snap.SideInfo{
RealName: "consumer",
},
})
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.Assert(change.Err(), IsNil)
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].Options, Equals, interfaces.ConfinementOptions{})
c.Check(s.secBackend.SetupCalls[1].Options, Equals, interfaces.ConfinementOptions{})
}
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")
ts.Tasks()[0].Set("snap-setup", &snapstate.SnapSetup{
SideInfo: &snap.SideInfo{
RealName: "consumer",
},
})
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()
c.Assert(change.Err(), IsNil)
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)
}
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) 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)
ts.Tasks()[0].Set("snap-setup", &snapstate.SnapSetup{
SideInfo: &snap.SideInfo{
RealName: "consumer",
},
})
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.Assert(change.Err(), IsNil)
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{}{})
}
func (s *interfaceManagerSuite) testDisconnect(c *C, plugSnap, plugName, slotSnap, slotName string) {
// Put two snaps in place They consumer has an plug that can be connected
// to slot on the producer.
s.mockIface(c, &interfaces.TestInterface{InterfaceName: "test"})
s.mockSnap(c, consumerYaml)
s.mockSnap(c, producerYaml)
// Put a connection in the state so that it automatically gets set up when
// we create the manager.
s.state.Lock()
s.state.Set("conns", map[string]interface{}{
"consumer:plug producer:slot": map[string]interface{}{"interface": "test"},
})
s.state.Unlock()
// Initialize the manager. This registers both snaps and reloads the connection.
mgr := s.manager(c)
// Run the disconnect task and let it finish.
s.state.Lock()
change := s.state.NewChange("disconnect", "...")
ts, err := ifacestate.Disconnect(s.state, plugSnap, plugName, slotSnap, slotName)
ts.Tasks()[0].Set("snap-setup", &snapstate.SnapSetup{
SideInfo: &snap.SideInfo{
RealName: "consumer",
},
})
c.Assert(err, IsNil)
change.AddAll(ts)
s.state.Unlock()
mgr.Ensure()
mgr.Wait()
s.state.Lock()
defer s.state.Unlock()
// Ensure that the task succeeded.
c.Assert(change.Err(), IsNil)
task := change.Tasks()[0]
c.Check(task.Kind(), Equals, "disconnect")
c.Check(task.Status(), Equals, state.DoneStatus)
c.Check(change.Status(), Equals, state.DoneStatus)
// Ensure that the connection has been removed from the state
var conns map[string]interface{}
err = s.state.Get("conns", &conns)
c.Assert(err, IsNil)
c.Check(conns, HasLen, 0)
// Ensure that the connection has been removed from the repository
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)
// Ensure that the backend was used to setup security of both snaps
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].Options, Equals, interfaces.ConfinementOptions{})
c.Check(s.secBackend.SetupCalls[1].Options, Equals, interfaces.ConfinementOptions{})
}