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 (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 *snapmgrTestSuite) TestInstallFirstLocalIntegration(c *C) { s.state.Lock() defer s.state.Unlock() 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, 5) 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[3].op, Equals, "candidate") c.Check(s.fakeBackend.ops[3].sinfo, DeepEquals, snap.SideInfo{Revision: 100001}) c.Check(s.fakeBackend.ops[4].op, Equals, "link-snap") c.Check(s.fakeBackend.ops[4].name, Equals, "/snap/mock/100001") // 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: 100001, 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[0], DeepEquals, &snap.SideInfo{ OfficialName: "", Channel: "", Revision: 100001, }) c.Assert(snapst.LocalRevision, Equals, 100001) }
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) doDiscardConns(task *state.Task, _ *tomb.Tomb) error { st := task.State() st.Lock() defer st.Unlock() snapSetup, err := snapstate.TaskSnapSetup(task) if err != nil { return err } snapName := snapSetup.Name var snapState snapstate.SnapState err = snapstate.Get(st, snapName, &snapState) if err != nil && err != state.ErrNoState { return err } if err == nil && len(snapState.Sequence) != 0 { return fmt.Errorf("cannot discard connections for snap %q while it is present", snapName) } conns, err := getConns(st) if err != nil { return err } removed := make(map[string]connState) for id := range conns { plugRef, slotRef, err := parseConnID(id) if err != nil { return err } if plugRef.Snap == snapName || slotRef.Snap == snapName { removed[id] = conns[id] delete(conns, id) } } task.Set("removed", removed) setConns(st, conns) return nil }
// 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 *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) 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 (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) 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 }
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 }