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 *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) }
// localSnapInfo returns the information about the current snap for the given name plus the SnapState with the active flag and other snap revisions. func localSnapInfo(st *state.State, name string) (info *snap.Info, active bool, err error) { st.Lock() defer st.Unlock() var snapst snapstate.SnapState err = snapstate.Get(st, name, &snapst) if err != nil && err != state.ErrNoState { return nil, false, fmt.Errorf("cannot consult state: %v", err) } cur := snapst.Current() if cur == nil { return nil, false, nil } info, err = snap.ReadInfo(name, cur) if err != nil { return nil, false, fmt.Errorf("cannot read snap details: %v", err) } return info, snapst.Active, nil }
func (s *snapmgrQuerySuite) TestAll(c *C) { st := s.st st.Lock() defer st.Unlock() snapStates, err := snapstate.All(st) c.Assert(err, IsNil) c.Check(snapStates, HasLen, 1) var snapst *snapstate.SnapState for name, sst := range snapStates { c.Assert(name, Equals, "name1") snapst = sst } c.Check(snapst.Active, Equals, true) c.Check(snapst.Current(), NotNil) info12, err := snap.ReadInfo("name1", snapst.Current()) c.Assert(err, IsNil) c.Check(info12.Name(), Equals, "name1") c.Check(info12.Revision, Equals, 12) c.Check(info12.Summary(), Equals, "s12") c.Check(info12.Version, Equals, "1.2") c.Check(info12.Description(), Equals, "Lots of text") info11, err := snap.ReadInfo("name1", snapst.Sequence[0]) c.Assert(err, IsNil) c.Check(info11.Name(), Equals, "name1") c.Check(info11.Revision, Equals, 11) c.Check(info11.Version, Equals, "1.1") }
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 (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 }
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 }