func (ms *mgrsSuite) TestHappyLocalInstall(c *C) {
snapYamlContent := `name: foo
apps:
bar:
command: bin/bar
`
snapPath := makeTestSnap(c, snapYamlContent+"version: 1.0")
st := ms.o.State()
st.Lock()
defer st.Unlock()
ts, err := snapstate.InstallPath(st, &snap.SideInfo{RealName: "foo"}, snapPath, "", snapstate.Flags{DevMode: true})
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()))
snap, err := snapstate.CurrentInfo(st, "foo")
c.Assert(err, IsNil)
// ensure that the binary wrapper file got generated with the right
// name
binaryWrapper := filepath.Join(dirs.SnapBinariesDir, "foo.bar")
c.Assert(osutil.IsSymlink(binaryWrapper), Equals, true)
// data dirs
c.Assert(osutil.IsDirectory(snap.DataDir()), Equals, true)
c.Assert(osutil.IsDirectory(snap.CommonDataDir()), Equals, true)
// snap file and its mounting
// after install the snap file is in the right dir
c.Assert(osutil.FileExists(filepath.Join(dirs.SnapBlobDir, "foo_x1.snap")), Equals, true)
// ensure the right unit is created
mup := systemd.MountUnitPath("/snap/foo/x1")
content, err := ioutil.ReadFile(mup)
c.Assert(err, IsNil)
c.Assert(string(content), Matches, "(?ms).*^Where=/snap/foo/x1")
c.Assert(string(content), Matches, "(?ms).*^What=/var/lib/snapd/snaps/foo_x1.snap")
}
func (ms *mgrsSuite) TestHappyRefreshControl(c *C) {
// test install through store and update, plus some mechanics
// of update
// TODO: ok to split if it gets too messy to maintain
ms.prereqSnapAssertions(c)
snapYamlContent := `name: foo
version: @VERSION@
`
ver := "1.0"
revno := "42"
snapPath, _ := ms.makeStoreTestSnap(c, strings.Replace(snapYamlContent, "@VERSION@", ver, -1), revno)
ms.serveSnap(snapPath, revno)
mockServer := ms.mockStore(c)
defer mockServer.Close()
st := ms.o.State()
st.Lock()
defer st.Unlock()
ts, err := snapstate.Install(st, "foo", "stable", snap.R(0), 0, 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()))
info, err := snapstate.CurrentInfo(st, "foo")
c.Assert(err, IsNil)
c.Check(info.Revision, Equals, snap.R(42))
// Refresh
// Setup refresh control
headers := map[string]interface{}{
"series": "16",
"snap-id": "bar-id",
"snap-name": "bar",
"publisher-id": "devdevdev",
"refresh-control": []interface{}{fooSnapID},
"timestamp": time.Now().Format(time.RFC3339),
}
snapDeclBar, err := ms.storeSigning.Sign(asserts.SnapDeclarationType, headers, nil, "")
c.Assert(err, IsNil)
err = ms.storeSigning.Add(snapDeclBar)
c.Assert(err, IsNil)
err = assertstate.Add(st, snapDeclBar)
c.Assert(err, IsNil)
snapstate.Set(st, "bar", &snapstate.SnapState{
Active: true,
Sequence: []*snap.SideInfo{
{RealName: "bar", SnapID: "bar-id", Revision: snap.R(1)},
},
Current: snap.R(1),
SnapType: "app",
})
develSigning := assertstest.NewSigningDB("devdevdev", develPrivKey)
develAccKey := assertstest.NewAccountKey(ms.storeSigning, ms.devAcct, nil, develPrivKey.PublicKey(), "")
err = ms.storeSigning.Add(develAccKey)
c.Assert(err, IsNil)
ver = "2.0"
revno = "50"
snapPath, _ = ms.makeStoreTestSnap(c, strings.Replace(snapYamlContent, "@VERSION@", ver, -1), revno)
ms.serveSnap(snapPath, revno)
updated, tss, err := snapstate.UpdateMany(st, []string{"foo"}, 0)
c.Check(updated, IsNil)
c.Check(tss, IsNil)
// no validation we, get an error
c.Check(err, ErrorMatches, `cannot refresh "foo" to revision 50: no validation by "bar"`)
// setup validation
headers = map[string]interface{}{
"series": "16",
"snap-id": "bar-id",
"approved-snap-id": fooSnapID,
"approved-snap-revision": "50",
"timestamp": time.Now().Format(time.RFC3339),
}
barValidation, err := develSigning.Sign(asserts.ValidationType, headers, nil, "")
c.Assert(err, IsNil)
err = ms.storeSigning.Add(barValidation)
c.Assert(err, IsNil)
// ... and try again
updated, tss, err = snapstate.UpdateMany(st, []string{"foo"}, 0)
c.Assert(err, IsNil)
c.Assert(updated, DeepEquals, []string{"foo"})
c.Assert(tss, HasLen, 1)
chg = st.NewChange("upgrade-snaps", "...")
chg.AddAll(tss[0])
st.Unlock()
err = ms.o.Settle()
st.Lock()
c.Assert(err, IsNil)
c.Assert(chg.Err(), IsNil)
c.Assert(chg.Status(), Equals, state.DoneStatus, Commentf("upgrade-snap change failed with: %v", chg.Err()))
info, err = snapstate.CurrentInfo(st, "foo")
c.Assert(err, IsNil)
c.Check(info.Revision, Equals, snap.R(50))
}
func (ms *mgrsSuite) TestHappyLocalInstallWithStoreMetadata(c *C) {
snapDecl := ms.prereqSnapAssertions(c)
snapYamlContent := `name: foo
apps:
bar:
command: bin/bar
`
snapPath := makeTestSnap(c, snapYamlContent+"version: 1.5")
si := &snap.SideInfo{
RealName: "foo",
SnapID: fooSnapID,
Revision: snap.R(55),
DeveloperID: "devdevdevID",
Developer: "devdevdev",
}
st := ms.o.State()
st.Lock()
defer st.Unlock()
// have the snap-declaration in the system db
err := assertstate.Add(st, ms.storeSigning.StoreAccountKey(""))
c.Assert(err, IsNil)
err = assertstate.Add(st, ms.devAcct)
c.Assert(err, IsNil)
err = assertstate.Add(st, snapDecl)
c.Assert(err, IsNil)
ts, err := snapstate.InstallPath(st, si, snapPath, "", snapstate.Flags{DevMode: true})
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()))
info, err := snapstate.CurrentInfo(st, "foo")
c.Assert(err, IsNil)
c.Check(info.Revision, Equals, snap.R(55))
c.Check(info.SnapID, Equals, fooSnapID)
c.Check(info.DeveloperID, Equals, "devdevdevID")
c.Check(info.Developer, Equals, "devdevdev")
c.Check(info.Version, Equals, "1.5")
// ensure that the binary wrapper file got generated with the right
// name
binaryWrapper := filepath.Join(dirs.SnapBinariesDir, "foo.bar")
c.Assert(osutil.IsSymlink(binaryWrapper), Equals, true)
// data dirs
c.Assert(osutil.IsDirectory(info.DataDir()), Equals, true)
c.Assert(osutil.IsDirectory(info.CommonDataDir()), Equals, true)
// snap file and its mounting
// after install the snap file is in the right dir
c.Assert(osutil.FileExists(filepath.Join(dirs.SnapBlobDir, "foo_55.snap")), Equals, true)
// ensure the right unit is created
mup := systemd.MountUnitPath("/snap/foo/55")
content, err := ioutil.ReadFile(mup)
c.Assert(err, IsNil)
c.Assert(string(content), Matches, "(?ms).*^Where=/snap/foo/55")
c.Assert(string(content), Matches, "(?ms).*^What=/var/lib/snapd/snaps/foo_55.snap")
}
func (ms *mgrsSuite) TestHappyRemoteInstallAndUpgradeSvc(c *C) {
// test install through store and update, plus some mechanics
// of update
// TODO: ok to split if it gets too messy to maintain
ms.prereqSnapAssertions(c)
snapYamlContent := `name: foo
version: @VERSION@
apps:
bar:
command: bin/bar
svc:
command: svc
daemon: forking
`
ver := "1.0"
revno := "42"
snapPath, digest := ms.makeStoreTestSnap(c, strings.Replace(snapYamlContent, "@VERSION@", ver, -1), revno)
ms.serveSnap(snapPath, revno)
mockServer := ms.mockStore(c)
defer mockServer.Close()
st := ms.o.State()
st.Lock()
defer st.Unlock()
ts, err := snapstate.Install(st, "foo", "stable", snap.R(0), 0, 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()))
info, err := snapstate.CurrentInfo(st, "foo")
c.Assert(err, IsNil)
c.Check(info.Revision, Equals, snap.R(42))
c.Check(info.SnapID, Equals, fooSnapID)
c.Check(info.DeveloperID, Equals, "devdevdev")
c.Check(info.Version, Equals, "1.0")
c.Check(info.Summary(), Equals, "Foo")
c.Check(info.Description(), Equals, "this is a description")
c.Check(info.Developer, Equals, "bar")
c.Assert(osutil.FileExists(info.MountFile()), Equals, true)
snapRev42, err := assertstate.DB(st).Find(asserts.SnapRevisionType, map[string]string{
"snap-sha3-384": digest,
})
c.Assert(err, IsNil)
c.Check(snapRev42.(*asserts.SnapRevision).SnapID(), Equals, fooSnapID)
c.Check(snapRev42.(*asserts.SnapRevision).SnapRevision(), Equals, 42)
// check service was setup properly
svcFile := filepath.Join(dirs.SnapServicesDir, "snap.foo.svc.service")
c.Assert(osutil.FileExists(svcFile), Equals, true)
stat, err := os.Stat(svcFile)
c.Assert(err, IsNil)
// should _not_ be executable
c.Assert(stat.Mode().String(), Equals, "-rw-r--r--")
// Refresh
ver = "2.0"
revno = "50"
snapPath, digest = ms.makeStoreTestSnap(c, strings.Replace(snapYamlContent, "@VERSION@", ver, -1), revno)
ms.serveSnap(snapPath, revno)
ts, err = snapstate.Update(st, "foo", "stable", snap.R(0), 0, snapstate.Flags{})
c.Assert(err, IsNil)
chg = st.NewChange("upgrade-snap", "...")
chg.AddAll(ts)
st.Unlock()
err = ms.o.Settle()
st.Lock()
c.Assert(err, IsNil)
c.Assert(chg.Err(), IsNil)
c.Assert(chg.Status(), Equals, state.DoneStatus, Commentf("upgrade-snap change failed with: %v", chg.Err()))
info, err = snapstate.CurrentInfo(st, "foo")
c.Assert(err, IsNil)
c.Check(info.Revision, Equals, snap.R(50))
c.Check(info.SnapID, Equals, fooSnapID)
c.Check(info.DeveloperID, Equals, "devdevdev")
c.Check(info.Version, Equals, "2.0")
snapRev50, err := assertstate.DB(st).Find(asserts.SnapRevisionType, map[string]string{
"snap-sha3-384": digest,
})
c.Assert(err, IsNil)
c.Check(snapRev50.(*asserts.SnapRevision).SnapID(), Equals, fooSnapID)
c.Check(snapRev50.(*asserts.SnapRevision).SnapRevision(), Equals, 50)
// check updated wrapper
symlinkTarget, err := os.Readlink(info.Apps["bar"].WrapperPath())
c.Assert(err, IsNil)
c.Assert(symlinkTarget, Equals, "/usr/bin/snap")
// check updated service file
content, err := ioutil.ReadFile(svcFile)
c.Assert(err, IsNil)
c.Assert(strings.Contains(string(content), "/var/snap/foo/"+revno), Equals, true)
}
func (s *FirstBootTestSuite) TestPopulateFromSeedHappyMultiAssertsFiles(c *C) {
// put a firstboot snap into the SnapBlobDir
snapYaml := `name: foo
version: 1.0`
mockSnapFile := snaptest.MakeTestSnapWithFiles(c, snapYaml, nil)
fooSnapFile := filepath.Join(dirs.SnapSeedDir, "snaps", filepath.Base(mockSnapFile))
err := os.Rename(mockSnapFile, fooSnapFile)
c.Assert(err, IsNil)
// put a 2nd firstboot snap into the SnapBlobDir
snapYaml = `name: bar
version: 1.0`
mockSnapFile = snaptest.MakeTestSnapWithFiles(c, snapYaml, nil)
barSnapFile := filepath.Join(dirs.SnapSeedDir, "snaps", filepath.Base(mockSnapFile))
err = os.Rename(mockSnapFile, barSnapFile)
c.Assert(err, IsNil)
devAcct := assertstest.NewAccount(s.storeSigning, "developer", map[string]interface{}{
"account-id": "developerid",
}, "")
snapDeclFoo, err := s.storeSigning.Sign(asserts.SnapDeclarationType, map[string]interface{}{
"series": "16",
"snap-id": "foosnapidsnapid",
"publisher-id": "developerid",
"snap-name": "foo",
"timestamp": time.Now().UTC().Format(time.RFC3339),
}, nil, "")
c.Assert(err, IsNil)
sha3_384, size, err := asserts.SnapFileSHA3_384(fooSnapFile)
c.Assert(err, IsNil)
snapRevFoo, err := s.storeSigning.Sign(asserts.SnapRevisionType, map[string]interface{}{
"snap-sha3-384": sha3_384,
"snap-size": fmt.Sprintf("%d", size),
"snap-id": "foosnapidsnapid",
"developer-id": "developerid",
"snap-revision": "128",
"timestamp": time.Now().UTC().Format(time.RFC3339),
}, nil, "")
c.Assert(err, IsNil)
writeAssertionsToFile("foo.asserts", []asserts.Assertion{devAcct, snapRevFoo, snapDeclFoo})
snapDeclBar, err := s.storeSigning.Sign(asserts.SnapDeclarationType, map[string]interface{}{
"series": "16",
"snap-id": "barsnapidsnapid",
"publisher-id": "developerid",
"snap-name": "bar",
"timestamp": time.Now().UTC().Format(time.RFC3339),
}, nil, "")
c.Assert(err, IsNil)
sha3_384, size, err = asserts.SnapFileSHA3_384(barSnapFile)
c.Assert(err, IsNil)
snapRevBar, err := s.storeSigning.Sign(asserts.SnapRevisionType, map[string]interface{}{
"snap-sha3-384": sha3_384,
"snap-size": fmt.Sprintf("%d", size),
"snap-id": "barsnapidsnapid",
"developer-id": "developerid",
"snap-revision": "65",
"timestamp": time.Now().UTC().Format(time.RFC3339),
}, nil, "")
c.Assert(err, IsNil)
writeAssertionsToFile("bar.asserts", []asserts.Assertion{devAcct, snapDeclBar, snapRevBar})
// add a model assertion and its chain
assertsChain := s.makeModelAssertionChain(c)
writeAssertionsToFile("model.asserts", assertsChain)
// create a seed.yaml
content := []byte(fmt.Sprintf(`
snaps:
- name: foo
file: %s
- name: bar
file: %s
`, filepath.Base(fooSnapFile), filepath.Base(barSnapFile)))
err = ioutil.WriteFile(filepath.Join(dirs.SnapSeedDir, "seed.yaml"), content, 0644)
c.Assert(err, IsNil)
// run the firstboot stuff
st := s.overlord.State()
st.Lock()
defer st.Unlock()
tsAll, err := devicestate.PopulateStateFromSeedImpl(st)
c.Assert(err, IsNil)
chg := st.NewChange("run-it", "run the populate from seed changes")
for _, ts := range tsAll {
chg.AddAll(ts)
}
c.Assert(st.Changes(), HasLen, 1)
st.Unlock()
s.overlord.Settle()
st.Lock()
c.Assert(chg.Err(), IsNil)
// and check the snap got correctly installed
c.Check(osutil.FileExists(filepath.Join(dirs.SnapMountDir, "foo", "128", "meta", "snap.yaml")), Equals, true)
// and check the snap got correctly installed
c.Check(osutil.FileExists(filepath.Join(dirs.SnapMountDir, "bar", "65", "meta", "snap.yaml")), Equals, true)
// verify
r, err := os.Open(dirs.SnapStateFile)
c.Assert(err, IsNil)
state, err := state.ReadState(nil, r)
c.Assert(err, IsNil)
state.Lock()
defer state.Unlock()
// check foo
info, err := snapstate.CurrentInfo(state, "foo")
c.Assert(err, IsNil)
c.Assert(info.SnapID, Equals, "foosnapidsnapid")
c.Assert(info.Revision, Equals, snap.R(128))
c.Assert(info.DeveloperID, Equals, "developerid")
// check bar
info, err = snapstate.CurrentInfo(state, "bar")
c.Assert(err, IsNil)
c.Assert(info.SnapID, Equals, "barsnapidsnapid")
c.Assert(info.Revision, Equals, snap.R(65))
c.Assert(info.DeveloperID, Equals, "developerid")
}
func (s *FirstBootTestSuite) TestPopulateFromSeedHappy(c *C) {
// put a firstboot snap into the SnapBlobDir
snapYaml := `name: foo
version: 1.0`
mockSnapFile := snaptest.MakeTestSnapWithFiles(c, snapYaml, nil)
targetSnapFile := filepath.Join(dirs.SnapSeedDir, "snaps", filepath.Base(mockSnapFile))
err := os.Rename(mockSnapFile, targetSnapFile)
c.Assert(err, IsNil)
// put a firstboot local snap into the SnapBlobDir
snapYaml = `name: local
version: 1.0`
mockSnapFile = snaptest.MakeTestSnapWithFiles(c, snapYaml, nil)
targetSnapFile2 := filepath.Join(dirs.SnapSeedDir, "snaps", filepath.Base(mockSnapFile))
err = os.Rename(mockSnapFile, targetSnapFile2)
c.Assert(err, IsNil)
devAcct := assertstest.NewAccount(s.storeSigning, "developer", map[string]interface{}{
"account-id": "developerid",
}, "")
devAcctFn := filepath.Join(dirs.SnapSeedDir, "assertions", "developer.account")
err = ioutil.WriteFile(devAcctFn, asserts.Encode(devAcct), 0644)
c.Assert(err, IsNil)
snapDecl, err := s.storeSigning.Sign(asserts.SnapDeclarationType, map[string]interface{}{
"series": "16",
"snap-id": "snapidsnapid",
"publisher-id": "developerid",
"snap-name": "foo",
"timestamp": time.Now().UTC().Format(time.RFC3339),
}, nil, "")
c.Assert(err, IsNil)
declFn := filepath.Join(dirs.SnapSeedDir, "assertions", "foo.snap-declaration")
err = ioutil.WriteFile(declFn, asserts.Encode(snapDecl), 0644)
c.Assert(err, IsNil)
sha3_384, size, err := asserts.SnapFileSHA3_384(targetSnapFile)
c.Assert(err, IsNil)
snapRev, err := s.storeSigning.Sign(asserts.SnapRevisionType, map[string]interface{}{
"snap-sha3-384": sha3_384,
"snap-size": fmt.Sprintf("%d", size),
"snap-id": "snapidsnapid",
"developer-id": "developerid",
"snap-revision": "128",
"timestamp": time.Now().UTC().Format(time.RFC3339),
}, nil, "")
c.Assert(err, IsNil)
revFn := filepath.Join(dirs.SnapSeedDir, "assertions", "foo.snap-revision")
err = ioutil.WriteFile(revFn, asserts.Encode(snapRev), 0644)
c.Assert(err, IsNil)
// add a model assertion and its chain
assertsChain := s.makeModelAssertionChain(c)
for i, as := range assertsChain {
fn := filepath.Join(dirs.SnapSeedDir, "assertions", strconv.Itoa(i))
err := ioutil.WriteFile(fn, asserts.Encode(as), 0644)
c.Assert(err, IsNil)
}
// create a seed.yaml
content := []byte(fmt.Sprintf(`
snaps:
- name: foo
file: %s
devmode: true
- name: local
unasserted: true
file: %s
`, filepath.Base(targetSnapFile), filepath.Base(targetSnapFile2)))
err = ioutil.WriteFile(filepath.Join(dirs.SnapSeedDir, "seed.yaml"), content, 0644)
c.Assert(err, IsNil)
// run the firstboot stuff
st := s.overlord.State()
st.Lock()
defer st.Unlock()
tsAll, err := devicestate.PopulateStateFromSeedImpl(st)
c.Assert(err, IsNil)
// the last task of the last taskset must be mark-seeded
markSeededTask := tsAll[len(tsAll)-1].Tasks()[0]
c.Check(markSeededTask.Kind(), Equals, "mark-seeded")
// and the markSeededTask must wait for the other tasks
prevTasks := tsAll[len(tsAll)-2].Tasks()
otherTask := prevTasks[len(prevTasks)-1]
c.Check(markSeededTask.WaitTasks(), testutil.Contains, otherTask)
// now run the change and check the result
chg := st.NewChange("run-it", "run the populate from seed changes")
for _, ts := range tsAll {
chg.AddAll(ts)
}
c.Assert(st.Changes(), HasLen, 1)
st.Unlock()
s.overlord.Settle()
st.Lock()
c.Assert(chg.Err(), IsNil)
// and check the snap got correctly installed
c.Check(osutil.FileExists(filepath.Join(dirs.SnapMountDir, "foo", "128", "meta", "snap.yaml")), Equals, true)
c.Check(osutil.FileExists(filepath.Join(dirs.SnapMountDir, "local", "x1", "meta", "snap.yaml")), Equals, true)
// verify
r, err := os.Open(dirs.SnapStateFile)
c.Assert(err, IsNil)
state, err := state.ReadState(nil, r)
c.Assert(err, IsNil)
state.Lock()
defer state.Unlock()
// check foo
info, err := snapstate.CurrentInfo(state, "foo")
c.Assert(err, IsNil)
c.Assert(info.SnapID, Equals, "snapidsnapid")
c.Assert(info.Revision, Equals, snap.R(128))
c.Assert(info.DeveloperID, Equals, "developerid")
var snapst snapstate.SnapState
err = snapstate.Get(state, "foo", &snapst)
c.Assert(err, IsNil)
c.Assert(snapst.DevMode, Equals, true)
// check local
info, err = snapstate.CurrentInfo(state, "local")
c.Assert(err, IsNil)
c.Assert(info.SnapID, Equals, "")
c.Assert(info.Revision, Equals, snap.R("x1"))
c.Assert(info.DeveloperID, Equals, "")
// and ensure state is now considered seeded
var seeded bool
err = state.Get("seeded", &seeded)
c.Assert(err, IsNil)
c.Check(seeded, Equals, true)
}
func (ms *mgrsSuite) TestHappyRemoteInstallAndUpdateAutoAliases(c *C) {
ms.prereqSnapAssertions(c, map[string]interface{}{
"snap-name": "foo",
"auto-aliases": []interface{}{"app1"},
})
fooYaml := `name: foo
version: @VERSION@
apps:
app1:
command: bin/app1
aliases: [app1]
app2:
command: bin/app2
aliases: [app2]
`
fooPath, _ := ms.makeStoreTestSnap(c, strings.Replace(fooYaml, "@VERSION@", "1.0", -1), "10")
ms.serveSnap(fooPath, "10")
mockServer := ms.mockStore(c)
defer mockServer.Close()
st := ms.o.State()
st.Lock()
defer st.Unlock()
ts, err := snapstate.Install(st, "foo", "stable", snap.R(0), 0, 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()))
info, err := snapstate.CurrentInfo(st, "foo")
c.Assert(err, IsNil)
c.Check(info.Revision, Equals, snap.R(10))
c.Check(info.Version, Equals, "1.0")
var allAliases map[string]map[string]string
err = st.Get("aliases", &allAliases)
c.Check(err, IsNil)
c.Check(allAliases, DeepEquals, map[string]map[string]string{
"foo": {
"app1": "auto",
},
})
app1Alias := filepath.Join(dirs.SnapBinariesDir, "app1")
dest, err := os.Readlink(app1Alias)
c.Assert(err, IsNil)
c.Check(dest, Equals, "foo.app1")
ms.prereqSnapAssertions(c, map[string]interface{}{
"snap-name": "foo",
"auto-aliases": []interface{}{"app2"},
"revision": "1",
})
// new foo version/revision
fooPath, _ = ms.makeStoreTestSnap(c, strings.Replace(fooYaml, "@VERSION@", "1.5", -1), "15")
ms.serveSnap(fooPath, "15")
// refresh all
updated, tss, err := snapstate.UpdateMany(st, nil, 0)
c.Assert(err, IsNil)
c.Assert(updated, DeepEquals, []string{"foo"})
c.Assert(tss, HasLen, 1)
chg = st.NewChange("upgrade-snaps", "...")
chg.AddAll(tss[0])
st.Unlock()
err = ms.o.Settle()
st.Lock()
c.Assert(err, IsNil)
c.Assert(chg.Status(), Equals, state.DoneStatus, Commentf("upgrade-snap change failed with: %v", chg.Err()))
info, err = snapstate.CurrentInfo(st, "foo")
c.Assert(err, IsNil)
c.Check(info.Revision, Equals, snap.R(15))
c.Check(info.Version, Equals, "1.5")
allAliases = nil
err = st.Get("aliases", &allAliases)
c.Check(err, IsNil)
c.Check(allAliases, DeepEquals, map[string]map[string]string{
"foo": {
"app2": "auto",
},
})
c.Check(osutil.IsSymlink(app1Alias), Equals, false)
app2Alias := filepath.Join(dirs.SnapBinariesDir, "app2")
dest, err = os.Readlink(app2Alias)
c.Assert(err, IsNil)
c.Check(dest, Equals, "foo.app2")
}
func (s *FirstBootTestSuite) TestPopulateFromSeedHappy(c *C) {
// put a firstboot snap into the SnapBlobDir
snapYaml := `name: foo
version: 1.0`
mockSnapFile := snaptest.MakeTestSnapWithFiles(c, snapYaml, nil)
targetSnapFile := filepath.Join(dirs.SnapSeedDir, "snaps", filepath.Base(mockSnapFile))
err := os.Rename(mockSnapFile, targetSnapFile)
c.Assert(err, IsNil)
// put a firstboot local snap into the SnapBlobDir
snapYaml = `name: local
version: 1.0`
mockSnapFile = snaptest.MakeTestSnapWithFiles(c, snapYaml, nil)
targetSnapFile2 := filepath.Join(dirs.SnapSeedDir, "snaps", filepath.Base(mockSnapFile))
err = os.Rename(mockSnapFile, targetSnapFile2)
c.Assert(err, IsNil)
devAcct := assertstest.NewAccount(s.storeSigning, "developer", map[string]interface{}{
"account-id": "developerid",
}, "")
devAcctFn := filepath.Join(dirs.SnapSeedDir, "assertions", "developer.account")
err = ioutil.WriteFile(devAcctFn, asserts.Encode(devAcct), 0644)
c.Assert(err, IsNil)
snapDecl, err := s.storeSigning.Sign(asserts.SnapDeclarationType, map[string]interface{}{
"series": "16",
"snap-id": "snapidsnapid",
"publisher-id": "developerid",
"snap-name": "foo",
"timestamp": time.Now().UTC().Format(time.RFC3339),
}, nil, "")
c.Assert(err, IsNil)
declFn := filepath.Join(dirs.SnapSeedDir, "assertions", "foo.snap-declaration")
err = ioutil.WriteFile(declFn, asserts.Encode(snapDecl), 0644)
c.Assert(err, IsNil)
sha3_384, size, err := asserts.SnapFileSHA3_384(targetSnapFile)
c.Assert(err, IsNil)
snapRev, err := s.storeSigning.Sign(asserts.SnapRevisionType, map[string]interface{}{
"snap-sha3-384": sha3_384,
"snap-size": fmt.Sprintf("%d", size),
"snap-id": "snapidsnapid",
"developer-id": "developerid",
"snap-revision": "128",
"timestamp": time.Now().UTC().Format(time.RFC3339),
}, nil, "")
c.Assert(err, IsNil)
revFn := filepath.Join(dirs.SnapSeedDir, "assertions", "foo.snap-revision")
err = ioutil.WriteFile(revFn, asserts.Encode(snapRev), 0644)
c.Assert(err, IsNil)
// add a model assertion and its chain
assertsChain := s.makeModelAssertionChain(c)
for i, as := range assertsChain {
fn := filepath.Join(dirs.SnapSeedDir, "assertions", strconv.Itoa(i))
err := ioutil.WriteFile(fn, asserts.Encode(as), 0644)
c.Assert(err, IsNil)
}
// create a seed.yaml
content := []byte(fmt.Sprintf(`
snaps:
- name: foo
file: %s
devmode: true
- name: local
unasserted: true
file: %s
`, filepath.Base(targetSnapFile), filepath.Base(targetSnapFile2)))
err = ioutil.WriteFile(filepath.Join(dirs.SnapSeedDir, "seed.yaml"), content, 0644)
c.Assert(err, IsNil)
// run the firstboot stuff
err = boot.PopulateStateFromSeed()
c.Assert(err, IsNil)
// and check the snap got correctly installed
c.Check(osutil.FileExists(filepath.Join(dirs.SnapMountDir, "foo", "128", "meta", "snap.yaml")), Equals, true)
c.Check(osutil.FileExists(filepath.Join(dirs.SnapMountDir, "local", "x1", "meta", "snap.yaml")), Equals, true)
// verify
r, err := os.Open(dirs.SnapStateFile)
c.Assert(err, IsNil)
state, err := state.ReadState(nil, r)
c.Assert(err, IsNil)
state.Lock()
defer state.Unlock()
// check foo
info, err := snapstate.CurrentInfo(state, "foo")
c.Assert(err, IsNil)
c.Assert(info.SnapID, Equals, "snapidsnapid")
c.Assert(info.Revision, Equals, snap.R(128))
c.Assert(info.DeveloperID, Equals, "developerid")
var snapst snapstate.SnapState
err = snapstate.Get(state, "foo", &snapst)
c.Assert(err, IsNil)
c.Assert(snapst.DevMode(), Equals, true)
// check local
info, err = snapstate.CurrentInfo(state, "local")
c.Assert(err, IsNil)
c.Assert(info.SnapID, Equals, "")
c.Assert(info.Revision, Equals, snap.R("x1"))
c.Assert(info.DeveloperID, Equals, "")
}
