func (s *apiSuite) mockSnap(c *C, yamlText string) *snap.Info {
if s.d == nil {
panic("call s.daemon(c) in your test first")
}
st := s.d.overlord.State()
st.Lock()
defer st.Unlock()
// Parse the yaml
snapInfo, err := snap.InfoFromSnapYaml([]byte(yamlText))
c.Assert(err, IsNil)
snap.AddImplicitSlots(snapInfo)
// Create on-disk yaml file (it is read by snapstate)
dname := filepath.Join(dirs.SnapSnapsDir, snapInfo.Name(),
strconv.Itoa(snapInfo.Revision), "meta")
fname := filepath.Join(dname, "snap.yaml")
err = os.MkdirAll(dname, 0755)
c.Assert(err, IsNil)
err = ioutil.WriteFile(fname, []byte(yamlText), 0644)
c.Assert(err, IsNil)
// Put a side info into the state
snapstate.Set(st, snapInfo.Name(), &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{{Revision: snapInfo.Revision}},
})
// Put the snap into the interface repository
repo := s.d.overlord.InterfaceManager().Repository()
err = repo.AddSnap(snapInfo)
c.Assert(err, IsNil)
return snapInfo
}
func populateStateFromInstalled() error {
all, err := (&snappy.Overlord{}).Installed()
if err != nil {
return err
}
if osutil.FileExists(dirs.SnapStateFile) {
return fmt.Errorf("cannot create state: state %q already exists", dirs.SnapStateFile)
}
st := state.New(&overlordStateBackend{
path: dirs.SnapStateFile,
})
st.Lock()
defer st.Unlock()
for _, sn := range all {
// no need to do a snapstate.Get() because this is firstboot
info := sn.Info()
var snapst snapstate.SnapState
snapst.Sequence = append(snapst.Sequence, &info.SideInfo)
snapst.Channel = info.Channel
snapst.Active = sn.IsActive()
snapstate.Set(st, sn.Name(), &snapst)
}
return nil
}
func (s *snapmgrTestSuite) TestRemoveLast(c *C) {
s.state.Lock()
defer s.state.Unlock()
snapstate.Set(s.state, "foo", &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{{OfficialName: "foo"}},
})
ts, err := snapstate.Remove(s.state, "foo", 0)
c.Assert(err, IsNil)
i := 0
c.Assert(ts.Tasks(), HasLen, 5)
// all tasks are accounted
c.Assert(s.state.Tasks(), HasLen, 5)
c.Assert(ts.Tasks()[i].Kind(), Equals, "unlink-snap")
i++
c.Assert(ts.Tasks()[i].Kind(), Equals, "remove-profiles")
i++
c.Assert(ts.Tasks()[i].Kind(), Equals, "clear-snap")
i++
c.Assert(ts.Tasks()[i].Kind(), Equals, "discard-snap")
i++
c.Assert(ts.Tasks()[i].Kind(), Equals, "discard-conns")
}
func (s *interfaceManagerSuite) mockSnap(c *C, yamlText string) *snap.Info {
s.state.Lock()
defer s.state.Unlock()
// Parse the yaml
snapInfo, err := snap.InfoFromSnapYaml([]byte(yamlText))
c.Assert(err, IsNil)
snap.AddImplicitSlots(snapInfo)
// Create on-disk yaml file (it is read by snapstate)
dname := filepath.Join(dirs.SnapSnapsDir, snapInfo.Name(),
strconv.Itoa(snapInfo.Revision), "meta")
fname := filepath.Join(dname, "snap.yaml")
err = os.MkdirAll(dname, 0755)
c.Assert(err, IsNil)
err = ioutil.WriteFile(fname, []byte(yamlText), 0644)
c.Assert(err, IsNil)
// Put a side info into the state
snapstate.Set(s.state, snapInfo.Name(), &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{{Revision: snapInfo.Revision}},
})
return snapInfo
}
func (s *snapmgrTestSuite) TestUpdateSameRevisionIntegration(c *C) {
si := snap.SideInfo{
OfficialName: "some-snap",
Revision: 7,
}
s.state.Lock()
defer s.state.Unlock()
snapstate.Set(s.state, "some-snap", &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{&si},
})
chg := s.state.NewChange("install", "install a snap")
ts, err := snapstate.Update(s.state, "some-snap", "channel-for-7", s.user.ID, snappy.DoInstallGC)
c.Assert(err, IsNil)
chg.AddAll(ts)
s.state.Unlock()
defer s.snapmgr.Stop()
s.settle()
s.state.Lock()
expected := []fakeOp{
{
op: "download",
macaroon: s.user.Macaroon,
name: "some-snap",
channel: "channel-for-7",
},
}
c.Assert(chg.Status(), Equals, state.ErrorStatus)
c.Check(chg.Err(), ErrorMatches, `(?s).*revision 7 of snap "some-snap" already installed.*`)
// ensure all our tasks ran
c.Assert(s.fakeBackend.ops, DeepEquals, expected)
// verify snaps in the system state
var snapst snapstate.SnapState
err = snapstate.Get(s.state, "some-snap", &snapst)
c.Assert(err, IsNil)
c.Assert(snapst.Active, Equals, true)
c.Assert(snapst.Candidate, IsNil)
c.Assert(snapst.Sequence, HasLen, 1)
c.Assert(snapst.Sequence[0], DeepEquals, &snap.SideInfo{
OfficialName: "some-snap",
Channel: "",
Revision: 7,
})
}
func (s *snapmgrQuerySuite) TestAllEmptyAndEmptyNormalisation(c *C) {
st := state.New(nil)
st.Lock()
defer st.Unlock()
snapStates, err := snapstate.All(st)
c.Assert(err, IsNil)
c.Check(snapStates, HasLen, 0)
snapstate.Set(st, "foo", nil)
snapStates, err = snapstate.All(st)
c.Assert(err, IsNil)
c.Check(snapStates, HasLen, 0)
snapstate.Set(st, "foo", &snapstate.SnapState{})
snapStates, err = snapstate.All(st)
c.Assert(err, IsNil)
c.Check(snapStates, HasLen, 0)
}
func (s *snapmgrTestSuite) TestRemoveConflict(c *C) {
s.state.Lock()
defer s.state.Unlock()
snapstate.Set(s.state, "some-snap", &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{{OfficialName: "some-snap"}},
})
_, err := snapstate.Remove(s.state, "some-snap", 0)
c.Assert(err, IsNil)
_, err = snapstate.Remove(s.state, "some-snap", 0)
c.Assert(err, ErrorMatches, `snap "some-snap" has changes in progress`)
}
func (s *interfaceManagerSuite) testUndoDicardConns(c *C, snapName string) {
s.state.Lock()
// Store information about a connection in the state.
s.state.Set("conns", map[string]interface{}{
"consumer:plug producer:slot": map[string]interface{}{"interface": "test"},
})
// Store empty snap state. This snap has an empty sequence now.
snapstate.Set(s.state, snapName, &snapstate.SnapState{})
s.state.Unlock()
mgr := s.manager(c)
// Run the discard-conns task and let it finish
change := s.addDiscardConnsChange(c, snapName)
mgr.Ensure()
mgr.Wait()
s.state.Lock()
c.Check(change.Status(), Equals, state.DoneStatus)
change.Abort()
s.state.Unlock()
mgr.Ensure()
mgr.Wait()
mgr.Stop()
s.state.Lock()
defer s.state.Unlock()
c.Assert(change.Status(), Equals, state.UndoneStatus)
// Information about the connection is intact
var conns map[string]interface{}
err := s.state.Get("conns", &conns)
c.Assert(err, IsNil)
c.Check(conns, DeepEquals, map[string]interface{}{
"consumer:plug producer:slot": map[string]interface{}{"interface": "test"},
})
var removed map[string]interface{}
err = change.Tasks()[0].Get("removed", &removed)
c.Assert(err, IsNil)
c.Check(removed, HasLen, 0)
}
func (s *snapmgrTestSuite) TestUpdateChannelFallback(c *C) {
s.state.Lock()
defer s.state.Unlock()
snapstate.Set(s.state, "some-snap", &snapstate.SnapState{
Active: true,
Channel: "edge",
Sequence: []*snap.SideInfo{{OfficialName: "some-snap", Revision: 11}},
})
ts, err := snapstate.Update(s.state, "some-snap", "", s.user.ID, 0)
c.Assert(err, IsNil)
var ss snapstate.SnapSetup
err = ts.Tasks()[0].Get("snap-setup", &ss)
c.Assert(err, IsNil)
c.Check(ss.Channel, Equals, "edge")
}
func (s *snapmgrQuerySuite) SetUpTest(c *C) {
st := state.New(nil)
st.Lock()
defer st.Unlock()
s.st = st
dirs.SetRootDir(c.MkDir())
// Write a snap.yaml with fake name
dname := filepath.Join(snap.MountDir("name1", 11), "meta")
err := os.MkdirAll(dname, 0775)
c.Assert(err, IsNil)
fname := filepath.Join(dname, "snap.yaml")
err = ioutil.WriteFile(fname, []byte(`
name: name0
version: 1.1
description: |
Lots of text`), 0644)
c.Assert(err, IsNil)
dname = filepath.Join(snap.MountDir("name1", 12), "meta")
err = os.MkdirAll(dname, 0775)
c.Assert(err, IsNil)
fname = filepath.Join(dname, "snap.yaml")
err = ioutil.WriteFile(fname, []byte(`
name: name0
version: 1.2
description: |
Lots of text`), 0644)
c.Assert(err, IsNil)
snapstate.Set(st, "name1", &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{
{OfficialName: "name1", Revision: 11, EditedSummary: "s11"},
{OfficialName: "name1", Revision: 12, EditedSummary: "s12"},
},
})
}
func (s *snapmgrTestSuite) TestUpdateUndoIntegration(c *C) {
si := snap.SideInfo{
OfficialName: "some-snap",
Revision: 7,
}
s.state.Lock()
defer s.state.Unlock()
snapstate.Set(s.state, "some-snap", &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{&si},
})
chg := s.state.NewChange("install", "install a snap")
ts, err := snapstate.Update(s.state, "some-snap", "some-channel", s.user.ID, snappy.DoInstallGC)
c.Assert(err, IsNil)
chg.AddAll(ts)
s.fakeBackend.linkSnapFailTrigger = "/snap/some-snap/11"
s.state.Unlock()
defer s.snapmgr.Stop()
s.settle()
s.state.Lock()
expected := []fakeOp{
{
op: "download",
macaroon: s.user.Macaroon,
name: "some-snap",
channel: "some-channel",
},
{
op: "check-snap",
name: "downloaded-snap-path",
flags: int(snappy.DoInstallGC),
old: "/snap/some-snap/7",
},
{
op: "setup-snap",
name: "downloaded-snap-path",
flags: int(snappy.DoInstallGC),
revno: 11,
},
{
op: "unlink-snap",
name: "/snap/some-snap/7",
},
{
op: "copy-data",
name: "/snap/some-snap/11",
flags: int(snappy.DoInstallGC),
old: "/snap/some-snap/7",
},
{
op: "candidate",
sinfo: snap.SideInfo{
OfficialName: "some-snap",
SnapID: "snapIDsnapidsnapidsnapidsnapidsn",
Channel: "some-channel",
Revision: 11,
},
},
{
op: "link-snap.failed",
name: "/snap/some-snap/11",
},
// no unlink-snap here is expected!
{
op: "undo-copy-snap-data",
name: "/snap/some-snap/11",
},
{
op: "link-snap",
name: "/snap/some-snap/7",
},
{
op: "undo-setup-snap",
name: "/snap/some-snap/11",
},
}
// ensure all our tasks ran
c.Assert(s.fakeBackend.ops, DeepEquals, expected)
// verify snaps in the system state
var snapst snapstate.SnapState
err = snapstate.Get(s.state, "some-snap", &snapst)
c.Assert(err, IsNil)
c.Assert(snapst.Active, Equals, true)
c.Assert(snapst.Candidate, IsNil)
c.Assert(snapst.Sequence, HasLen, 1)
c.Assert(snapst.Sequence[0], DeepEquals, &snap.SideInfo{
OfficialName: "some-snap",
Channel: "",
Revision: 7,
})
}
func (s *snapmgrTestSuite) TestRemoveIntegration(c *C) {
si := snap.SideInfo{
OfficialName: "some-snap",
Revision: 7,
}
s.state.Lock()
defer s.state.Unlock()
snapstate.Set(s.state, "some-snap", &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{&si},
})
chg := s.state.NewChange("remove", "remove a snap")
ts, err := snapstate.Remove(s.state, "some-snap", 0)
c.Assert(err, IsNil)
chg.AddAll(ts)
s.state.Unlock()
defer s.snapmgr.Stop()
s.settle()
s.state.Lock()
c.Assert(s.fakeBackend.ops, HasLen, 4)
expected := []fakeOp{
fakeOp{
op: "can-remove",
name: "/snap/some-snap/7",
active: true,
},
fakeOp{
op: "unlink-snap",
name: "/snap/some-snap/7",
},
fakeOp{
op: "remove-snap-data",
name: "/snap/some-snap/7",
},
fakeOp{
op: "remove-snap-files",
name: "/snap/some-snap/7",
},
}
c.Assert(s.fakeBackend.ops, DeepEquals, expected)
// verify snapSetup info
tasks := ts.Tasks()
// snap-setup is in discard-snap above discard-conns.
task := tasks[len(tasks)-2]
var ss snapstate.SnapSetup
err = task.Get("snap-setup", &ss)
c.Assert(err, IsNil)
c.Assert(ss, DeepEquals, snapstate.SnapSetup{
Name: "some-snap",
Revision: 7,
})
// verify snaps in the system state
var snapst snapstate.SnapState
err = snapstate.Get(s.state, "some-snap", &snapst)
c.Assert(err, Equals, state.ErrNoState)
}
func (s *snapmgrTestSuite) TestInstallSubequentLocalIntegration(c *C) {
s.state.Lock()
defer s.state.Unlock()
snapstate.Set(s.state, "mock", &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{{Revision: 100002}},
LocalRevision: 100002,
})
mockSnap := makeTestSnap(c, `name: mock
version: 1.0`)
chg := s.state.NewChange("install", "install a local snap")
ts, err := snapstate.InstallPath(s.state, mockSnap, "", 0)
c.Assert(err, IsNil)
chg.AddAll(ts)
s.state.Unlock()
defer s.snapmgr.Stop()
s.settle()
s.state.Lock()
// ensure only local install was run, i.e. first action is check-snap
c.Assert(s.fakeBackend.ops, HasLen, 6)
c.Check(s.fakeBackend.ops[0].op, Equals, "check-snap")
c.Check(s.fakeBackend.ops[0].name, Matches, `.*/mock_1.0_all.snap`)
c.Check(s.fakeBackend.ops[2].op, Equals, "unlink-snap")
c.Check(s.fakeBackend.ops[2].name, Equals, "/snap/mock/100002")
c.Check(s.fakeBackend.ops[3].op, Equals, "copy-data")
c.Check(s.fakeBackend.ops[3].name, Equals, "/snap/mock/100003")
c.Check(s.fakeBackend.ops[3].old, Equals, "/snap/mock/100002")
c.Check(s.fakeBackend.ops[4].op, Equals, "candidate")
c.Check(s.fakeBackend.ops[4].sinfo, DeepEquals, snap.SideInfo{Revision: 100003})
c.Check(s.fakeBackend.ops[5].op, Equals, "link-snap")
c.Check(s.fakeBackend.ops[5].name, Equals, "/snap/mock/100003")
// verify snapSetup info
var ss snapstate.SnapSetup
task := ts.Tasks()[0]
err = task.Get("snap-setup", &ss)
c.Assert(err, IsNil)
c.Assert(ss, DeepEquals, snapstate.SnapSetup{
Name: "mock",
Revision: 100003,
SnapPath: mockSnap,
})
// verify snaps in the system state
var snapst snapstate.SnapState
err = snapstate.Get(s.state, "mock", &snapst)
c.Assert(err, IsNil)
c.Assert(snapst.Active, Equals, true)
c.Assert(snapst.Candidate, IsNil)
c.Assert(snapst.Sequence, HasLen, 2)
c.Assert(snapst.Current(), DeepEquals, &snap.SideInfo{
OfficialName: "",
Channel: "",
Revision: 100003,
})
c.Assert(snapst.LocalRevision, Equals, 100003)
}
func (s *snapmgrTestSuite) TestUpdateTotalUndoIntegration(c *C) {
si := snap.SideInfo{
OfficialName: "some-snap",
Revision: 7,
}
s.state.Lock()
defer s.state.Unlock()
snapstate.Set(s.state, "some-snap", &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{&si},
Channel: "stable",
})
chg := s.state.NewChange("install", "install a snap")
ts, err := snapstate.Update(s.state, "some-snap", "some-channel", s.user.ID, snappy.DoInstallGC)
c.Assert(err, IsNil)
chg.AddAll(ts)
tasks := ts.Tasks()
last := tasks[len(tasks)-1]
terr := s.state.NewTask("error-trigger", "provoking total undo")
terr.WaitFor(last)
chg.AddTask(terr)
s.state.Unlock()
defer s.snapmgr.Stop()
s.settle()
s.state.Lock()
expected := []fakeOp{
{
op: "download",
macaroon: s.user.Macaroon,
name: "some-snap",
channel: "some-channel",
},
{
op: "check-snap",
name: "downloaded-snap-path",
flags: int(snappy.DoInstallGC),
old: "/snap/some-snap/7",
},
{
op: "setup-snap",
name: "downloaded-snap-path",
flags: int(snappy.DoInstallGC),
revno: 11,
},
{
op: "unlink-snap",
name: "/snap/some-snap/7",
},
{
op: "copy-data",
name: "/snap/some-snap/11",
flags: int(snappy.DoInstallGC),
old: "/snap/some-snap/7",
},
{
op: "candidate",
sinfo: snap.SideInfo{
OfficialName: "some-snap",
SnapID: "snapIDsnapidsnapidsnapidsnapidsn",
Channel: "some-channel",
Revision: 11,
},
},
{
op: "link-snap",
name: "/snap/some-snap/11",
},
// undoing everything from here down...
{
op: "unlink-snap",
name: "/snap/some-snap/11",
},
{
op: "undo-copy-snap-data",
name: "/snap/some-snap/11",
},
{
op: "link-snap",
name: "/snap/some-snap/7",
},
{
op: "undo-setup-snap",
name: "/snap/some-snap/11",
},
}
// ensure all our tasks ran
c.Assert(s.fakeBackend.ops, DeepEquals, expected)
// verify snaps in the system state
var snapst snapstate.SnapState
err = snapstate.Get(s.state, "some-snap", &snapst)
c.Assert(err, IsNil)
c.Assert(snapst.Active, Equals, true)
c.Assert(snapst.Channel, Equals, "stable")
c.Assert(snapst.Candidate, IsNil)
c.Assert(snapst.Sequence, HasLen, 1)
c.Assert(snapst.Sequence[0], DeepEquals, &snap.SideInfo{
OfficialName: "some-snap",
Channel: "",
Revision: 7,
})
}
func (m *InterfaceManager) doRemoveProfiles(task *state.Task, _ *tomb.Tomb) error {
st := task.State()
st.Lock()
defer st.Unlock()
// Get SnapSetup for this snap. This is gives us the name of the snap.
snapSetup, err := snapstate.TaskSnapSetup(task)
if err != nil {
return err
}
snapName := snapSetup.Name
// Get SnapState for this snap
var snapState snapstate.SnapState
err = snapstate.Get(st, snapName, &snapState)
if err != nil && err != state.ErrNoState {
return err
}
// Get the old-devmode flag from the task.
// This flag is set by setup-profiles in case we have to undo.
var oldDevMode bool
err = task.Get("old-devmode", &oldDevMode)
if err != nil && err != state.ErrNoState {
return err
}
// Restore the state of DevMode flag if old-devmode was saved in the task.
if err == nil {
if oldDevMode {
snapState.Flags |= snapstate.DevMode
} else {
snapState.Flags &= ^snapstate.DevMode
}
snapstate.Set(st, snapName, &snapState)
}
// Disconnect the snap entirely.
// This is required to remove the snap from the interface repository.
// The returned list of affected snaps will need to have its security setup
// to reflect the change.
affectedSnaps, err := m.repo.DisconnectSnap(snapName)
if err != nil {
return err
}
// Setup security of the affected snaps.
for _, snapInfo := range affectedSnaps {
if snapInfo.Name() == snapName {
// Skip setup for the snap being removed as this is handled below.
continue
}
if err := setupSnapSecurity(task, snapInfo, m.repo); err != nil {
return state.Retry
}
}
// Remove the snap from the interface repository.
// This discards all the plugs and slots belonging to that snap.
if err := m.repo.RemoveSnap(snapName); err != nil {
return err
}
// Remove security artefacts of the snap.
if err := removeSnapSecurity(task, snapName); err != nil {
return state.Retry
}
return nil
}
func (s *snapmgrTestSuite) TestUpdateIntegration(c *C) {
si := snap.SideInfo{
OfficialName: "some-snap",
Revision: 7,
}
s.state.Lock()
defer s.state.Unlock()
snapstate.Set(s.state, "some-snap", &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{&si},
})
chg := s.state.NewChange("install", "install a snap")
ts, err := snapstate.Update(s.state, "some-snap", "some-channel", s.user.ID, snappy.DoInstallGC)
c.Assert(err, IsNil)
chg.AddAll(ts)
s.state.Unlock()
defer s.snapmgr.Stop()
s.settle()
s.state.Lock()
expected := []fakeOp{
fakeOp{
op: "download",
macaroon: s.user.Macaroon,
name: "some-snap",
channel: "some-channel",
},
fakeOp{
op: "check-snap",
name: "downloaded-snap-path",
flags: int(snappy.DoInstallGC),
old: "/snap/some-snap/7",
},
fakeOp{
op: "setup-snap",
name: "downloaded-snap-path",
flags: int(snappy.DoInstallGC),
revno: 11,
},
fakeOp{
op: "unlink-snap",
name: "/snap/some-snap/7",
},
fakeOp{
op: "copy-data",
name: "/snap/some-snap/11",
flags: int(snappy.DoInstallGC),
old: "/snap/some-snap/7",
},
fakeOp{
op: "candidate",
sinfo: snap.SideInfo{
OfficialName: "some-snap",
SnapID: "snapIDsnapidsnapidsnapidsnapidsn",
Channel: "some-channel",
Revision: 11,
},
},
fakeOp{
op: "link-snap",
name: "/snap/some-snap/11",
},
}
// ensure all our tasks ran
c.Assert(s.fakeBackend.ops, DeepEquals, expected)
// check progress
task := ts.Tasks()[0]
cur, total := task.Progress()
c.Assert(cur, Equals, s.fakeBackend.fakeCurrentProgress)
c.Assert(total, Equals, s.fakeBackend.fakeTotalProgress)
// verify snapSetup info
var ss snapstate.SnapSetup
err = task.Get("snap-setup", &ss)
c.Assert(err, IsNil)
c.Assert(ss, DeepEquals, snapstate.SnapSetup{
Name: "some-snap",
Channel: "some-channel",
Flags: int(snappy.DoInstallGC),
UserID: s.user.ID,
Revision: 11,
SnapPath: "downloaded-snap-path",
})
// verify snaps in the system state
var snapst snapstate.SnapState
err = snapstate.Get(s.state, "some-snap", &snapst)
c.Assert(err, IsNil)
c.Assert(snapst.Active, Equals, true)
c.Assert(snapst.Candidate, IsNil)
c.Assert(snapst.Sequence, HasLen, 2)
c.Assert(snapst.Sequence[0], DeepEquals, &snap.SideInfo{
OfficialName: "some-snap",
Channel: "",
Revision: 7,
})
c.Assert(snapst.Sequence[1], DeepEquals, &snap.SideInfo{
OfficialName: "some-snap",
Channel: "some-channel",
SnapID: "snapIDsnapidsnapidsnapidsnapidsn",
Revision: 11,
})
}
func (m *InterfaceManager) doSetupProfiles(task *state.Task, _ *tomb.Tomb) error {
task.State().Lock()
defer task.State().Unlock()
// Get snap.Info from bits handed by the snap manager.
ss, err := snapstate.TaskSnapSetup(task)
if err != nil {
return err
}
snapInfo, err := snapstate.Info(task.State(), ss.Name, ss.Revision)
if err != nil {
return err
}
snap.AddImplicitSlots(snapInfo)
snapName := snapInfo.Name()
var snapState snapstate.SnapState
if err := snapstate.Get(task.State(), snapName, &snapState); err != nil {
task.Errorf("cannot get state of snap %q: %s", snapName, err)
return err
}
// Set DevMode flag if SnapSetup.Flags indicates it should be done
// but remember the old value in the task in case we undo.
task.Set("old-devmode", snapState.DevMode())
if ss.DevMode() {
snapState.Flags |= snapstate.DevMode
} else {
snapState.Flags &= ^snapstate.DevMode
}
snapstate.Set(task.State(), snapName, &snapState)
// The snap may have been updated so perform the following operation to
// ensure that we are always working on the correct state:
//
// - disconnect all connections to/from the given snap
// - remembering the snaps that were affected by this operation
// - remove the (old) snap from the interfaces repository
// - add the (new) snap to the interfaces repository
// - restore connections based on what is kept in the state
// - if a connection cannot be restored then remove it from the state
// - setup the security of all the affected snaps
blacklist := m.repo.AutoConnectBlacklist(snapName)
affectedSnaps, err := m.repo.DisconnectSnap(snapName)
if err != nil {
return err
}
// XXX: what about snap renames? We should remove the old name (or switch
// to IDs in the interfaces repository)
if err := m.repo.RemoveSnap(snapName); err != nil {
return err
}
if err := m.repo.AddSnap(snapInfo); err != nil {
if _, ok := err.(*interfaces.BadInterfacesError); ok {
logger.Noticef("%s", err)
} else {
return err
}
}
if err := m.reloadConnections(snapName); err != nil {
return err
}
if err := m.autoConnect(task, snapName, blacklist); err != nil {
return err
}
if len(affectedSnaps) == 0 {
affectedSnaps = append(affectedSnaps, snapInfo)
}
for _, snapInfo := range affectedSnaps {
if err := setupSnapSecurity(task, snapInfo, m.repo); err != nil {
return state.Retry
}
}
return nil
}
