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)
}