func (s *deviceMgrSuite) TestDeviceManagerEnsureBootOkBootloaderHappy(c *C) { release.OnClassic = false bootloader := boottest.NewMockBootloader("mock", c.MkDir()) partition.ForceBootloader(bootloader) defer partition.ForceBootloader(nil) bootloader.SetBootVars(map[string]string{ "snap_mode": "trying", "snap_try_core": "core_1.snap", }) s.state.Lock() defer s.state.Unlock() siCore1 := &snap.SideInfo{RealName: "core", Revision: snap.R(1)} snapstate.Set(s.state, "core", &snapstate.SnapState{ SnapType: "os", Active: true, Sequence: []*snap.SideInfo{siCore1}, Current: siCore1.Revision, }) s.state.Unlock() err := s.mgr.EnsureBootOk() s.state.Lock() c.Assert(err, IsNil) m, err := bootloader.GetBootVars("snap_mode") c.Assert(err, IsNil) c.Assert(m, DeepEquals, map[string]string{"snap_mode": ""}) }
func (s *deviceMgrSuite) TestDeviceManagerEnsureBootOkUpdateBootRevisionsHappy(c *C) { release.OnClassic = false bootloader := boottest.NewMockBootloader("mock", c.MkDir()) partition.ForceBootloader(bootloader) defer partition.ForceBootloader(nil) // simulate that we have a new core_2, tried to boot it but that failed bootloader.SetBootVars(map[string]string{ "snap_mode": "", "snap_try_core": "core_2.snap", "snap_core": "core_1.snap", }) s.state.Lock() defer s.state.Unlock() siCore1 := &snap.SideInfo{RealName: "core", Revision: snap.R(1)} siCore2 := &snap.SideInfo{RealName: "core", Revision: snap.R(2)} snapstate.Set(s.state, "core", &snapstate.SnapState{ SnapType: "os", Active: true, Sequence: []*snap.SideInfo{siCore1, siCore2}, Current: siCore2.Revision, }) s.state.Unlock() err := s.mgr.EnsureBootOk() s.state.Lock() c.Assert(err, IsNil) c.Check(s.state.Changes(), HasLen, 1) c.Check(s.state.Changes()[0].Kind(), Equals, "update-revisions") }
func (s *kernelOSSuite) TestExtractKernelAssetsNoUnpacksKernelForGrub(c *C) { // pretend to be a grub system mockGrub := boottest.NewMockBootloader("grub", c.MkDir()) partition.ForceBootloader(mockGrub) files := [][]string{ {"kernel.img", "I'm a kernel"}, {"initrd.img", "...and I'm an initrd"}, {"meta/kernel.yaml", "version: 4.2"}, } si := &snap.SideInfo{ RealName: "ubuntu-kernel", Revision: snap.R(42), } fn := snaptest.MakeTestSnapWithFiles(c, packageKernel, files) snapf, err := snap.Open(fn) c.Assert(err, IsNil) info, err := snap.ReadInfoFromSnapFile(snapf, si) c.Assert(err, IsNil) err = boot.ExtractKernelAssets(info, snapf) c.Assert(err, IsNil) // kernel is *not* here kernimg := filepath.Join(mockGrub.Dir(), "ubuntu-kernel_42.snap", "kernel.img") c.Assert(osutil.FileExists(kernimg), Equals, false) }
func (s *deviceMgrSuite) TestDeviceManagerEnsureBootOkNotRunAgain(c *C) { release.OnClassic = false bootloader := boottest.NewMockBootloader("mock", c.MkDir()) bootloader.SetBootVars(map[string]string{ "snap_mode": "trying", "snap_try_core": "core_1.snap", }) bootloader.SetErr = fmt.Errorf("ensure bootloader is not used") partition.ForceBootloader(bootloader) defer partition.ForceBootloader(nil) s.mgr.SetBootOkRan(true) err := s.mgr.EnsureBootOk() c.Assert(err, IsNil) }
func (ms *mgrsSuite) TestInstallKernelSnapUpdatesBootloader(c *C) { bootloader := boottest.NewMockBootloader("mock", c.MkDir()) partition.ForceBootloader(bootloader) defer partition.ForceBootloader(nil) restore := release.MockOnClassic(false) defer restore() const packageKernel = ` name: krnl version: 4.0-1 type: kernel` files := [][]string{ {"kernel.img", "I'm a kernel"}, {"initrd.img", "...and I'm an initrd"}, {"meta/kernel.yaml", "version: 4.2"}, } snapPath := snaptest.MakeTestSnapWithFiles(c, packageKernel, files) st := ms.o.State() st.Lock() defer st.Unlock() ts, err := snapstate.InstallPath(st, &snap.SideInfo{RealName: "krnl"}, snapPath, "", 0) c.Assert(err, IsNil) chg := st.NewChange("install-snap", "...") chg.AddAll(ts) st.Unlock() err = ms.o.Settle() st.Lock() c.Assert(err, IsNil) c.Assert(chg.Status(), Equals, state.DoneStatus, Commentf("install-snap change failed with: %v", chg.Err())) c.Assert(bootloader.BootVars, DeepEquals, map[string]string{ "snap_try_kernel": "krnl_x1.snap", "snap_mode": "try", }) }
func (s *setupSuite) TestSetupUndoIdempotent(c *C) { // make sure that a retry wouldn't stumble on partial work // use a kernel because that does and need to do strictly more // this cannot check systemd own behavior though around mounts! bootloader := boottest.NewMockBootloader("mock", c.MkDir()) partition.ForceBootloader(bootloader) // we don't get real mounting os.Setenv("SNAPPY_SQUASHFS_UNPACK_FOR_TESTS", "1") defer os.Unsetenv("SNAPPY_SQUASHFS_UNPACK_FOR_TESTS") testFiles := [][]string{ {"kernel.img", "kernel"}, {"initrd.img", "initrd"}, {"modules/4.4.0-14-generic/foo.ko", "a module"}, {"firmware/bar.bin", "some firmware"}, {"meta/kernel.yaml", "version: 4.2"}, } snapPath := snaptest.MakeTestSnapWithFiles(c, `name: kernel version: 1.0 type: kernel `, testFiles) si := snap.SideInfo{ RealName: "kernel", Revision: snap.R(140), } err := s.be.SetupSnap(snapPath, &si, &s.nullProgress) c.Assert(err, IsNil) minInfo := snap.MinimalPlaceInfo("kernel", snap.R(140)) err = s.be.UndoSetupSnap(minInfo, "kernel", &s.nullProgress) c.Assert(err, IsNil) // retry run err = s.be.UndoSetupSnap(minInfo, "kernel", &s.nullProgress) c.Assert(err, IsNil) // sanity checks l, _ := filepath.Glob(filepath.Join(dirs.SnapServicesDir, "*.mount")) c.Assert(l, HasLen, 0) c.Assert(osutil.FileExists(minInfo.MountDir()), Equals, false) c.Assert(osutil.FileExists(minInfo.MountFile()), Equals, false) l, _ = filepath.Glob(filepath.Join(bootloader.Dir(), "*")) c.Assert(l, HasLen, 0) }
func (ms *mgrsSuite) TestInstallCoreSnapUpdatesBootloader(c *C) { bootloader := boottest.NewMockBootloader("mock", c.MkDir()) partition.ForceBootloader(bootloader) defer partition.ForceBootloader(nil) restore := release.MockOnClassic(false) defer restore() const packageOS = ` name: core version: 16.04-1 type: os ` snapPath := makeTestSnap(c, packageOS) st := ms.o.State() st.Lock() defer st.Unlock() ts, err := snapstate.InstallPath(st, &snap.SideInfo{RealName: "core"}, snapPath, "", 0) c.Assert(err, IsNil) chg := st.NewChange("install-snap", "...") chg.AddAll(ts) st.Unlock() err = ms.o.Settle() st.Lock() c.Assert(err, IsNil) c.Assert(chg.Status(), Equals, state.DoneStatus, Commentf("install-snap change failed with: %v", chg.Err())) c.Assert(bootloader.BootVars, DeepEquals, map[string]string{ "snap_try_core": "core_x1.snap", "snap_mode": "try", }) }
func (s *deviceMgrSuite) TestDeviceManagerEnsureBootOkError(c *C) { release.OnClassic = false s.state.Lock() // seeded s.state.Set("seeded", true) // has serial auth.SetDevice(s.state, &auth.DeviceState{ Brand: "canonical", Model: "pc", Serial: "8989", }) s.state.Unlock() bootloader := boottest.NewMockBootloader("mock", c.MkDir()) bootloader.GetErr = fmt.Errorf("bootloader err") partition.ForceBootloader(bootloader) defer partition.ForceBootloader(nil) s.mgr.SetBootOkRan(false) err := s.mgr.Ensure() c.Assert(err, ErrorMatches, "devicemgr: bootloader err") }
func (bs *bootedSuite) SetUpTest(c *C) { dirs.SetRootDir(c.MkDir()) err := os.MkdirAll(filepath.Dir(dirs.SnapStateFile), 0755) c.Assert(err, IsNil) // booted is not running on classic release.MockOnClassic(false) bs.bootloader = boottest.NewMockBootloader("mock", c.MkDir()) bs.bootloader.BootVars["snap_core"] = "ubuntu-core_2.snap" bs.bootloader.BootVars["snap_kernel"] = "canonical-pc-linux_2.snap" partition.ForceBootloader(bs.bootloader) ovld, err := overlord.New() c.Assert(err, IsNil) bs.overlord = ovld }
func (bs *bootedSuite) SetUpTest(c *C) { dirs.SetRootDir(c.MkDir()) err := os.MkdirAll(filepath.Dir(dirs.SnapStateFile), 0755) c.Assert(err, IsNil) // booted is not running on classic release.MockOnClassic(false) bs.bootloader = boottest.NewMockBootloader("mock", c.MkDir()) bs.bootloader.BootVars["snap_core"] = "core_2.snap" bs.bootloader.BootVars["snap_kernel"] = "canonical-pc-linux_2.snap" partition.ForceBootloader(bs.bootloader) bs.fakeBackend = &fakeSnappyBackend{} bs.state = state.New(nil) bs.snapmgr, err = snapstate.Manager(bs.state) c.Assert(err, IsNil) bs.snapmgr.AddForeignTaskHandlers(bs.fakeBackend) snapstate.SetSnapManagerBackend(bs.snapmgr, bs.fakeBackend) }
func (s *imageSuite) SetUpTest(c *C) { s.root = c.MkDir() s.bootloader = boottest.NewMockBootloader("grub", c.MkDir()) partition.ForceBootloader(s.bootloader) s.stdout = bytes.NewBuffer(nil) image.Stdout = s.stdout s.downloadedSnaps = make(map[string]string) s.storeSnapInfo = make(map[string]*snap.Info) rootPrivKey, _ := assertstest.GenerateKey(1024) storePrivKey, _ := assertstest.GenerateKey(752) s.storeSigning = assertstest.NewStoreStack("can0nical", rootPrivKey, storePrivKey) brandPrivKey, _ := assertstest.GenerateKey(752) s.brandSigning = assertstest.NewSigningDB("my-brand", brandPrivKey) brandAcct := assertstest.NewAccount(s.storeSigning, "my-brand", map[string]interface{}{ "account-id": "my-brand", "verification": "certified", }, "") s.storeSigning.Add(brandAcct) brandAccKey := assertstest.NewAccountKey(s.storeSigning, brandAcct, nil, brandPrivKey.PublicKey(), "") s.storeSigning.Add(brandAccKey) model, err := s.brandSigning.Sign(asserts.ModelType, map[string]interface{}{ "series": "16", "authority-id": "my-brand", "brand-id": "my-brand", "model": "my-model", "architecture": "amd64", "gadget": "pc", "kernel": "pc-kernel", "required-snaps": []interface{}{"required-snap1"}, "timestamp": time.Now().Format(time.RFC3339), }, nil, "") c.Assert(err, IsNil) s.model = model.(*asserts.Model) }
func (s *setupSuite) TestSetupDoUndoKernelUboot(c *C) { bootloader := boottest.NewMockBootloader("mock", c.MkDir()) partition.ForceBootloader(bootloader) // we don't get real mounting os.Setenv("SNAPPY_SQUASHFS_UNPACK_FOR_TESTS", "1") defer os.Unsetenv("SNAPPY_SQUASHFS_UNPACK_FOR_TESTS") testFiles := [][]string{ {"kernel.img", "kernel"}, {"initrd.img", "initrd"}, {"modules/4.4.0-14-generic/foo.ko", "a module"}, {"firmware/bar.bin", "some firmware"}, {"meta/kernel.yaml", "version: 4.2"}, } snapPath := snaptest.MakeTestSnapWithFiles(c, `name: kernel version: 1.0 type: kernel `, testFiles) si := snap.SideInfo{ RealName: "kernel", Revision: snap.R(140), } err := s.be.SetupSnap(snapPath, &si, &s.nullProgress) c.Assert(err, IsNil) l, _ := filepath.Glob(filepath.Join(bootloader.Dir(), "*")) c.Assert(l, HasLen, 1) minInfo := snap.MinimalPlaceInfo("kernel", snap.R(140)) // undo deletes the kernel assets again err = s.be.UndoSetupSnap(minInfo, "kernel", &s.nullProgress) c.Assert(err, IsNil) l, _ = filepath.Glob(filepath.Join(bootloader.Dir(), "*")) c.Assert(l, HasLen, 0) }
func (s *kernelOSSuite) TearDownTest(c *C) { dirs.SetRootDir("") partition.ForceBootloader(nil) }
func (s *kernelOSSuite) SetUpTest(c *C) { dirs.SetRootDir(c.MkDir()) s.bootloader = boottest.NewMockBootloader("mock", c.MkDir()) partition.ForceBootloader(s.bootloader) }
func (ms *mgrsSuite) TestInstallKernelSnapUpdatesBootloader(c *C) { bootloader := boottest.NewMockBootloader("mock", c.MkDir()) partition.ForceBootloader(bootloader) defer partition.ForceBootloader(nil) restore := release.MockOnClassic(false) defer restore() brandAcct := assertstest.NewAccount(ms.storeSigning, "my-brand", map[string]interface{}{ "account-id": "my-brand", "verification": "certified", }, "") brandAccKey := assertstest.NewAccountKey(ms.storeSigning, brandAcct, nil, brandPrivKey.PublicKey(), "") brandSigning := assertstest.NewSigningDB("my-brand", brandPrivKey) model, err := brandSigning.Sign(asserts.ModelType, map[string]interface{}{ "series": "16", "authority-id": "my-brand", "brand-id": "my-brand", "model": "my-model", "architecture": "amd64", "store": "my-brand-store-id", "gadget": "gadget", "kernel": "krnl", "timestamp": time.Now().Format(time.RFC3339), }, nil, "") c.Assert(err, IsNil) const packageKernel = ` name: krnl version: 4.0-1 type: kernel` files := [][]string{ {"kernel.img", "I'm a kernel"}, {"initrd.img", "...and I'm an initrd"}, {"meta/kernel.yaml", "version: 4.2"}, } snapPath := snaptest.MakeTestSnapWithFiles(c, packageKernel, files) st := ms.o.State() st.Lock() defer st.Unlock() // setup model assertion err = assertstate.Add(st, ms.storeSigning.StoreAccountKey("")) c.Assert(err, IsNil) err = assertstate.Add(st, brandAcct) c.Assert(err, IsNil) err = assertstate.Add(st, brandAccKey) c.Assert(err, IsNil) auth.SetDevice(st, &auth.DeviceState{ Brand: "my-brand", Model: "my-model", }) err = assertstate.Add(st, model) c.Assert(err, IsNil) ts, err := snapstate.InstallPath(st, &snap.SideInfo{RealName: "krnl"}, snapPath, "", snapstate.Flags{}) c.Assert(err, IsNil) chg := st.NewChange("install-snap", "...") chg.AddAll(ts) st.Unlock() err = ms.o.Settle() st.Lock() c.Assert(err, IsNil) c.Assert(chg.Status(), Equals, state.DoneStatus, Commentf("install-snap change failed with: %v", chg.Err())) c.Assert(bootloader.BootVars, DeepEquals, map[string]string{ "snap_try_kernel": "krnl_x1.snap", "snap_mode": "try", }) }
func (s *setupSuite) TearDownTest(c *C) { dirs.SetRootDir("") partition.ForceBootloader(nil) systemd.SystemctlCmd = s.prevctlCmd s.umount.Restore() }
func (bs *bootedSuite) TearDownTest(c *C) { dirs.SetRootDir("") partition.ForceBootloader(nil) }
func (s *imageSuite) TearDownTest(c *C) { partition.ForceBootloader(nil) image.Stdout = os.Stdout }
func (bs *bootedSuite) TearDownTest(c *C) { release.MockOnClassic(true) dirs.SetRootDir("") partition.ForceBootloader(nil) }