func (s *interfaceManagerSuite) undoDevModeCheck(c *C, flags snappy.InstallFlags, devMode bool) {
// Put the OS and sample snaps in place.
s.mockSnap(c, osSnapYaml)
snapInfo := s.mockSnap(c, sampleSnapYaml)
// Initialize the manager. This registers both snaps.
mgr := s.manager(c)
// Run the setup-profiles task in UndoMode and let it finish.
change := s.addSetupSnapSecurityChange(c, &snapstate.SnapSetup{
Name: snapInfo.Name(), Flags: int(flags), Revision: snapInfo.Revision})
s.state.Lock()
task := change.Tasks()[0]
// Inject the old value of DevMode flag for the task handler to restore
task.Set("old-devmode", devMode)
task.SetStatus(state.UndoStatus)
s.state.Unlock()
mgr.Ensure()
mgr.Wait()
mgr.Stop()
// Change succeeds
s.state.Lock()
defer s.state.Unlock()
c.Check(change.Status(), Equals, state.UndoneStatus)
// SnapState.Flags now holds the original value of DevMode
var snapState snapstate.SnapState
err := snapstate.Get(s.state, snapInfo.Name(), &snapState)
c.Assert(err, IsNil)
c.Check(snapState.DevMode(), Equals, devMode)
}
func setupSnapSecurity(task *state.Task, snapInfo *snap.Info, repo *interfaces.Repository) error {
st := task.State()
var snapState snapstate.SnapState
snapName := snapInfo.Name()
if err := snapstate.Get(st, snapName, &snapState); err != nil {
task.Errorf("cannot get state of snap %q: %s", snapName, err)
return err
}
for _, backend := range securityBackends {
st.Unlock()
err := backend.Setup(snapInfo, snapState.DevMode(), repo)
st.Lock()
if err != nil {
task.Errorf("cannot setup %s for snap %q: %s", backend.Name(), snapName, err)
return err
}
}
return nil
}
// The setup-profiles task will honor snappy.DeveloperMode flag by storing it
// in the SnapState.Flags (as DevMode) and by actually setting up security
// using that flag. Old copy of SnapState.Flag's DevMode is saved for the undo
// handler under `old-devmode`.
func (s *interfaceManagerSuite) TestSetupProfilesHonorsDevMode(c *C) {
// Put the OS snap in place.
mgr := s.manager(c)
// Initialize the manager. This registers the OS snap.
snapInfo := s.mockSnap(c, sampleSnapYaml)
// Run the setup-profiles task and let it finish.
// Note that the task will see SnapSetup.Flags equal to DeveloperMode.
change := s.addSetupSnapSecurityChange(c, &snapstate.SnapSetup{
Name: snapInfo.Name(), Flags: int(snappy.DeveloperMode), Revision: snapInfo.Revision})
mgr.Ensure()
mgr.Wait()
mgr.Stop()
s.state.Lock()
defer s.state.Unlock()
// Ensure that the task succeeded.
c.Check(change.Status(), Equals, state.DoneStatus)
// The snap was setup with DevMode equal to true.
c.Assert(s.secBackend.SetupCalls, HasLen, 1)
c.Assert(s.secBackend.RemoveCalls, HasLen, 0)
c.Check(s.secBackend.SetupCalls[0].SnapInfo.Name(), Equals, "snap")
c.Check(s.secBackend.SetupCalls[0].DevMode, Equals, true)
// SnapState stored the value of DevMode
var snapState snapstate.SnapState
err := snapstate.Get(s.state, snapInfo.Name(), &snapState)
c.Assert(err, IsNil)
c.Check(snapState.DevMode(), Equals, true)
// The old value of DevMode was saved in the task in case undo is needed.
task := change.Tasks()[0]
var oldDevMode bool
err = task.Get("old-devmode", &oldDevMode)
c.Assert(err, IsNil)
c.Check(oldDevMode, Equals, false)
}
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
}
