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 }