interfaces: disconnect hooks

daemon/api.go

@@ -1874,7 +1874,11 @@ func changeInterfaces(c *Command, r *http.Request, user *auth.UserState) Respons
 			}
 			for _, connRef := range conns {
 				var ts *state.TaskSet
-				ts, err = ifacestate.Disconnect(st, connRef.PlugRef.Snap, connRef.PlugRef.Name, connRef.SlotRef.Snap, connRef.SlotRef.Name)
+				conn, err := repo.Connection(connRef)
+				if err != nil {
+					break
+				}
+				ts, err = ifacestate.Disconnect(st, conn)
 				if err != nil {
 					break
 				}

daemon/api_test.go

@@ -4255,6 +4255,15 @@ func (s *apiSuite) testDisconnect(c *check.C, plugSnap, plugName, slotSnap, slot
 	_, err := repo.Connect(connRef, nil, nil, nil)
 	c.Assert(err, check.IsNil)
 
+	st := d.overlord.State()
+	st.Lock()
+	st.Set("conns", map[string]interface{}{
+		"consumer:plug producer:slot": map[string]interface{}{
+			"interface": "test",
+		},
+	})
+	st.Unlock()
+
 	d.overlord.Loop()
 	defer d.overlord.Stop()
 
@@ -4276,7 +4285,6 @@ func (s *apiSuite) testDisconnect(c *check.C, plugSnap, plugName, slotSnap, slot
 	c.Check(err, check.IsNil)
 	id := body["change"].(string)
 
-	st := d.overlord.State()
 	st.Lock()
 	chg := st.Change(id)
 	st.Unlock()
@@ -4460,6 +4468,15 @@ func (s *apiSuite) TestDisconnectCoreSystemAlias(c *check.C) {
 	_, err := repo.Connect(connRef, nil, nil, nil)
 	c.Assert(err, check.IsNil)
 
+	st := d.overlord.State()
+	st.Lock()
+	st.Set("conns", map[string]interface{}{
+		"consumer:plug core:slot": map[string]interface{}{
+			"interface": "test",
+		},
+	})
+	st.Unlock()
+
 	d.overlord.Loop()
 	defer d.overlord.Stop()
 
@@ -4481,7 +4498,6 @@ func (s *apiSuite) TestDisconnectCoreSystemAlias(c *check.C) {
 	c.Check(err, check.IsNil)
 	id := body["change"].(string)
 
-	st := d.overlord.State()
 	st.Lock()
 	chg := st.Change(id)
 	st.Unlock()

interfaces/repo.go

@@ -277,6 +277,29 @@ func (r *Repository) Plug(snapName, plugName string) *snap.PlugInfo {
 	return r.plugs[snapName][plugName]
 }
 
+// Connection returns the specified Connection object or an error.
+func (r *Repository) Connection(connRef *ConnRef) (*Connection, error) {
+	// Ensure that such plug exists
+	plug := r.plugs[connRef.PlugRef.Snap][connRef.PlugRef.Name]
+	if plug == nil {
+		return nil, fmt.Errorf("snap %q has no plug named %q", connRef.PlugRef.Snap, connRef.PlugRef.Name)
+	}
+	// Ensure that such slot exists
+	slot := r.slots[connRef.SlotRef.Snap][connRef.SlotRef.Name]
+	if slot == nil {
+		return nil, fmt.Errorf("snap %q has no slot named %q", connRef.SlotRef.Snap, connRef.SlotRef.Name)
+	}
+	// Ensure that slot and plug are connected
+	conn, ok := r.slotPlugs[slot][plug]
+	if !ok {
+		return nil, fmt.Errorf("no connection from %s:%s to %s:%s",
+			connRef.PlugRef.Snap, connRef.PlugRef.Name,
+			connRef.SlotRef.Snap, connRef.SlotRef.Name)
+	}
+
+	return conn, nil
+}
+
 // AddPlug adds a plug to the repository.
 // Plug names must be valid snap names, as defined by ValidateName.
 // Plug name must be unique within a particular snap.
@@ -760,6 +783,10 @@ func (r *Repository) Connections(snapName string) ([]*ConnRef, error) {
 	}
 	for _, slotInfo := range r.slots[snapName] {
 		for plugInfo := range r.slotPlugs[slotInfo] {
+			// self-connection, ignore here as we got it already in the plugs loop above
+			if plugInfo.Snap == slotInfo.Snap {
+				continue
+			}
 			connRef := NewConnRef(plugInfo, slotInfo)
 			conns = append(conns, connRef)
 		}

interfaces/repo_test.go

@@ -36,6 +36,7 @@ type RepositorySuite struct {
 	testutil.BaseTest
 	iface     Interface
 	plug      *snap.PlugInfo
+	plugSelf  *snap.PlugInfo
 	slot      *snap.SlotInfo
 	emptyRepo *Repository
 	// Repository pre-populated with s.iface
@@ -83,9 +84,13 @@ slots:
         interface: interface
         label: label
         attr: value
+plugs:
+    self:
+        interface: interface
+        label: label
 `, nil)
 	s.slot = producer.Slots["slot"]
-
+	s.plugSelf = producer.Plugs["self"]
 	// NOTE: Each of the snaps below have one slot so that they can be picked
 	// up by the repository. Some tests rename the "slot" slot as appropriate.
 	s.ubuntuCoreSnap = snaptest.MockInfo(c, `
@@ -96,6 +101,9 @@ slots:
     slot:
         interface: interface
 `, nil)
+	// NOTE: The core snap has a slot so that it shows up in the
+	// repository. The repository doesn't record snaps unless they
+	// have at least one interface.
 	s.coreSnap = snaptest.MockInfo(c, `
 name: core
 version: 0
@@ -1356,6 +1364,21 @@ func (s *RepositorySuite) TestConnections(c *C) {
 	c.Assert(conns, HasLen, 0)
 }
 
+func (s *RepositorySuite) TestConnectionsWithSelfConnected(c *C) {
+	c.Assert(s.testRepo.AddPlug(s.plugSelf), IsNil)
+	c.Assert(s.testRepo.AddSlot(s.slot), IsNil)
+	_, err := s.testRepo.Connect(NewConnRef(s.plugSelf, s.slot), nil, nil, nil)
+	c.Assert(err, IsNil)
+
+	conns, err := s.testRepo.Connections(s.plugSelf.Snap.InstanceName())
+	c.Assert(err, IsNil)
+	c.Check(conns, DeepEquals, []*ConnRef{NewConnRef(s.plugSelf, s.slot)})
+
+	conns, err = s.testRepo.Connections(s.slot.Snap.InstanceName())
+	c.Assert(err, IsNil)
+	c.Check(conns, DeepEquals, []*ConnRef{NewConnRef(s.plugSelf, s.slot)})
+}
+
 // Tests for Repository.DisconnectAll()
 
 func (s *RepositorySuite) TestDisconnectAll(c *C) {
@@ -2156,6 +2179,30 @@ func (s *RepositorySuite) TestBeforeConnectValidationPolicyCheckFailure(c *C) {
 	c.Assert(conn, IsNil)
 }
 
+func (s *RepositorySuite) TestConnection(c *C) {
+	c.Assert(s.testRepo.AddPlug(s.plug), IsNil)
+	c.Assert(s.testRepo.AddSlot(s.slot), IsNil)
+
+	connRef := NewConnRef(s.plug, s.slot)
+
+	conn, err := s.testRepo.Connection(connRef)
+	c.Assert(err, ErrorMatches, `no connection from consumer:plug to producer:slot`)
+
+	_, err = s.testRepo.Connect(connRef, nil, nil, nil)
+	c.Assert(err, IsNil)
+
+	conn, err = s.testRepo.Connection(connRef)
+	c.Assert(err, IsNil)
+	c.Assert(conn.Plug.Name(), Equals, "plug")
+	c.Assert(conn.Slot.Name(), Equals, "slot")
+
+	conn, err = s.testRepo.Connection(&ConnRef{PlugRef: PlugRef{Snap: "a", Name: "b"}, SlotRef: SlotRef{Snap: "producer", Name: "slot"}})
+	c.Assert(err, ErrorMatches, `snap "a" has no plug named "b"`)
+
+	conn, err = s.testRepo.Connection(&ConnRef{PlugRef: PlugRef{Snap: "consumer", Name: "plug"}, SlotRef: SlotRef{Snap: "a", Name: "b"}})
+	c.Assert(err, ErrorMatches, `snap "a" has no slot named "b"`)
+}
+
 type hotplugTestInterface struct{ InterfaceName string }
 
 func (h *hotplugTestInterface) Name() string {

overlord/hookstate/ctlcmd/get.go

@@ -194,22 +194,36 @@ type ifaceHookType int
 const (
 	preparePlugHook ifaceHookType = iota
 	prepareSlotHook
+	unpreparePlugHook
+	unprepareSlotHook
 	connectPlugHook
 	connectSlotHook
+	disconnectPlugHook
+	disconnectSlotHook
 	unknownHook
 )
 
 func interfaceHookType(hookName string) (ifaceHookType, error) {
-	if strings.HasPrefix(hookName, "prepare-plug-") {
+	switch {
+	case strings.HasPrefix(hookName, "prepare-plug-"):
 		return preparePlugHook, nil
-	} else if strings.HasPrefix(hookName, "connect-plug-") {
+	case strings.HasPrefix(hookName, "connect-plug-"):
 		return connectPlugHook, nil
-	} else if strings.HasPrefix(hookName, "prepare-slot-") {
+	case strings.HasPrefix(hookName, "prepare-slot-"):
 		return prepareSlotHook, nil
-	} else if strings.HasPrefix(hookName, "connect-slot-") {
+	case strings.HasPrefix(hookName, "connect-slot-"):
 		return connectSlotHook, nil
+	case strings.HasPrefix(hookName, "disconnect-plug-"):
+		return disconnectPlugHook, nil
+	case strings.HasPrefix(hookName, "disconnect-slot-"):
+		return disconnectSlotHook, nil
+	case strings.HasPrefix(hookName, "unprepare-slot-"):
+		return unprepareSlotHook, nil
+	case strings.HasPrefix(hookName, "unprepare-plug-"):
+		return unpreparePlugHook, nil
+	default:
+		return unknownHook, fmt.Errorf("unknown hook type")
 	}
-	return unknownHook, fmt.Errorf("unknown hook type")
 }
 
 func validatePlugOrSlot(attrsTask *state.Task, plugSide bool, plugOrSlot string) error {
@@ -275,7 +289,7 @@ func (c *getCommand) getInterfaceSetting(context *hookstate.Context, plugOrSlot
 		return fmt.Errorf("cannot use --plug and --slot together")
 	}
 
-	isPlugSide := (hookType == preparePlugHook || hookType == connectPlugHook)
+	isPlugSide := (hookType == preparePlugHook || hookType == unpreparePlugHook || hookType == connectPlugHook || hookType == disconnectPlugHook)
 	if err = validatePlugOrSlot(attrsTask, isPlugSide, plugOrSlot); err != nil {
 		return err
 	}

overlord/hookstate/ctlcmd/get_test.go

@@ -223,7 +223,6 @@ func (s *getAttrSuite) SetUpTest(c *C) {
 	attrsTask.Set("plug-dynamic", dynamicPlugAttrs)
 	attrsTask.Set("slot-static", staticSlotAttrs)
 	attrsTask.Set("slot-dynamic", dynamicSlotAttrs)
-
 	ch.AddTask(attrsTask)
 	state.Unlock()
 

overlord/ifacestate/export_test.go

@@ -24,13 +24,13 @@ import (
 )
 
 var (
-	AddImplicitSlots          = addImplicitSlots
-	SnapsWithSecurityProfiles = snapsWithSecurityProfiles
-	CheckConnectConflicts     = checkConnectConflicts
-	FindSymmetricAutoconnect  = findSymmetricAutoconnect
-	ConnectPriv               = connect
-	GetConns                  = getConns
-	SetConns                  = setConns
+	AddImplicitSlots             = addImplicitSlots
+	SnapsWithSecurityProfiles    = snapsWithSecurityProfiles
+	CheckAutoconnectConflicts    = checkAutoconnectConflicts
+	FindSymmetricAutoconnectTask = findSymmetricAutoconnectTask
+	ConnectPriv                  = connect
+	GetConns                     = getConns
+	SetConns                     = setConns
 )
 
 func MockRemoveStaleConnections(f func(st *state.State) error) (restore func()) {