func addPackageDesktopFiles(s *snap.Info) error {
if err := os.MkdirAll(dirs.SnapDesktopFilesDir, 0755); err != nil {
return err
}
baseDir := s.MountDir()
desktopFiles, err := filepath.Glob(filepath.Join(baseDir, "meta", "gui", "*.desktop"))
if err != nil {
return fmt.Errorf("cannot get desktop files for %v: %s", baseDir, err)
}
for _, df := range desktopFiles {
content, err := ioutil.ReadFile(df)
if err != nil {
return err
}
realBaseDir := stripGlobalRootDir(baseDir)
content = sanitizeDesktopFile(s, realBaseDir, content)
installedDesktopFileName := filepath.Join(dirs.SnapDesktopFilesDir, fmt.Sprintf("%s_%s", s.Name(), filepath.Base(df)))
if err := osutil.AtomicWriteFile(installedDesktopFileName, []byte(content), 0755, 0); err != nil {
return err
}
}
return nil
}
// UnlinkSnap deactivates the given active snap.
func UnlinkSnap(info *snap.Info, inter interacter) error {
mountDir := info.MountDir()
currentSymlink := filepath.Join(mountDir, "..", "current")
currentActiveDir, err := filepath.EvalSymlinks(currentSymlink)
if err != nil {
if os.IsNotExist(err) {
return ErrSnapNotActive
}
return err
}
if mountDir != currentActiveDir {
return ErrSnapNotActive
}
// remove generated services, binaries, security policy
err1 := RemoveGeneratedWrappers(info, inter)
// removing security setup move here!
// and finally remove current symlink
err2 := removeCurrentSymlink(info, inter)
// FIXME: aggregate errors instead
return firstErr(err1, err2)
}
// CanInstall checks whether the Snap passes a series of tests required for installation
func canInstall(s *snap.Info, snapf snap.File, curInfo *snap.Info, allowGadget bool, inter interacter) error {
// verify we have a valid architecture
if !arch.IsSupportedArchitecture(s.Architectures) {
return &ErrArchitectureNotSupported{s.Architectures}
}
if s.Type == snap.TypeGadget {
if !allowGadget {
if currentGadget, err := getGadget(); err == nil {
if currentGadget.Name() != s.Name() {
return ErrGadgetPackageInstall
}
} else {
// there should always be a gadget package now
return ErrGadgetPackageInstall
}
}
}
if err := checkLicenseAgreement(s, snapf, curInfo, inter); err != nil {
return err
}
return nil
}
func addPackageBinaries(s *snap.Info) error {
if err := os.MkdirAll(dirs.SnapBinariesDir, 0755); err != nil {
return err
}
baseDir := s.MountDir()
for _, app := range s.Apps {
if app.Daemon != "" {
continue
}
// this will remove the global base dir when generating the
// service file, this ensures that /snap/foo/1.0/bin/start
// is in the service file when the SetRoot() option
// is used
realBaseDir := stripGlobalRootDir(baseDir)
content, err := generateSnapBinaryWrapper(app, realBaseDir)
if err != nil {
return err
}
if err := osutil.AtomicWriteFile(app.WrapperPath(), []byte(content), 0755, 0); err != nil {
return err
}
}
return nil
}
func (f *fakeSnappyBackend) RemoveSnapData(info *snap.Info) error {
f.ops = append(f.ops, fakeOp{
op: "remove-snap-data",
name: info.MountDir(),
})
return nil
}
// Download downloads the given snap and returns its filename.
// The file is saved in temporary storage, and should be removed
// after use to prevent the disk from running out of space.
func (s *SnapUbuntuStoreRepository) Download(remoteSnap *snap.Info, pbar progress.Meter, auther Authenticator) (path string, err error) {
w, err := ioutil.TempFile("", remoteSnap.Name())
if err != nil {
return "", err
}
defer func() {
if cerr := w.Close(); cerr != nil && err == nil {
err = cerr
}
if err != nil {
os.Remove(w.Name())
path = ""
}
}()
url := remoteSnap.AnonDownloadURL
if url == "" || auther != nil {
url = remoteSnap.DownloadURL
}
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return "", err
}
s.applyUbuntuStoreHeaders(req, "", auther)
if err := download(remoteSnap.Name(), w, req, pbar); err != nil {
return "", err
}
return w.Name(), w.Sync()
}
func (f *fakeSnappyBackend) UndoCopySnapData(newInfo *snap.Info, flags int) error {
f.ops = append(f.ops, fakeOp{
op: "undo-copy-snap-data",
name: newInfo.MountDir(),
})
return nil
}
// setNextBoot will schedule the given os or kernel snap to be used in
// the next boot
func setNextBoot(s *snap.Info) error {
if s.Type != snap.TypeOS && s.Type != snap.TypeKernel {
return nil
}
bootloader, err := findBootloader()
if err != nil {
return fmt.Errorf("can not set next boot: %s", err)
}
var bootvar string
switch s.Type {
case snap.TypeOS:
bootvar = "snappy_os"
case snap.TypeKernel:
bootvar = "snappy_kernel"
}
blobName := filepath.Base(s.MountFile())
if err := bootloader.SetBootVar(bootvar, blobName); err != nil {
return err
}
if err := bootloader.SetBootVar("snappy_mode", "try"); err != nil {
return err
}
return nil
}
func UndoCopyData(newInfo *snap.Info, flags InstallFlags, meter progress.Meter) {
// XXX we were copying data, assume InhibitHooks was false
if err := RemoveSnapData(newInfo); err != nil {
logger.Noticef("When cleaning up data for %s %s: %v", newInfo.Name(), newInfo.Version, err)
}
}
// snapDate returns the time of the snap mount directory.
func snapDate(info *snap.Info) time.Time {
st, err := os.Stat(info.MountDir())
if err != nil {
return time.Time{}
}
return st.ModTime()
}
func (f *fakeSnappyBackend) UnlinkSnap(info *snap.Info, meter progress.Meter) error {
meter.Notify("unlink")
f.ops = append(f.ops, fakeOp{
op: "unlink-snap",
name: info.MountDir(),
})
return nil
}
func (f *fakeSnappyBackend) CanRemove(info *snap.Info, active bool) bool {
f.ops = append(f.ops, fakeOp{
op: "can-remove",
name: info.MountDir(),
active: active,
})
return true
}
// snapIcon tries to find the icon inside the snap
func snapIcon(info *snap.Info) string {
// XXX: copy of snap.Snap.Icon which will go away
found, _ := filepath.Glob(filepath.Join(info.MountDir(), "meta", "gui", "icon.*"))
if len(found) == 0 {
return ""
}
return found[0]
}
// extractKernelAssets extracts kernel/initrd/dtb data from the given
// Snap to a versionized bootloader directory so that the bootloader
// can use it.
func extractKernelAssets(s *snap.Info, snapf snap.File, flags InstallFlags, inter progress.Meter) error {
if s.Type != snap.TypeKernel {
return fmt.Errorf("can not extract kernel assets from snap type %q", s.Type)
}
bootloader, err := findBootloader()
if err != nil {
return fmt.Errorf("can not extract kernel assets: %s", err)
}
// check if we are on a "grub" system. if so, no need to unpack
// the kernel
if oem, err := getGadget(); err == nil {
if oem.Legacy.Gadget.Hardware.Bootloader == "grub" {
return nil
}
}
// now do the kernel specific bits
blobName := filepath.Base(s.MountFile())
dstDir := filepath.Join(bootloader.Dir(), blobName)
if err := os.MkdirAll(dstDir, 0755); err != nil {
return err
}
dir, err := os.Open(dstDir)
if err != nil {
return err
}
defer dir.Close()
for _, src := range []string{s.Legacy.Kernel, s.Legacy.Initrd} {
if src == "" {
continue
}
if err := snapf.Unpack(src, dstDir); err != nil {
return err
}
src = filepath.Join(dstDir, src)
dst := filepath.Join(dstDir, dropVersionSuffix(src))
if err := os.Rename(src, dst); err != nil {
return err
}
if err := dir.Sync(); err != nil {
return err
}
}
if s.Legacy.Dtbs != "" {
src := filepath.Join(s.Legacy.Dtbs, "*")
dst := dstDir
if err := snapf.Unpack(src, dst); err != nil {
return err
}
}
return dir.Sync()
}
// updateSnap "updates" an existing snap from YAML.
func (s *backendSuite) updateSnap(c *C, oldSnapInfo *snap.Info, devMode bool, snapYaml string) *snap.Info {
newSnapInfo, err := snap.InfoFromSnapYaml([]byte(snapYaml))
c.Assert(err, IsNil)
c.Assert(newSnapInfo.Name(), Equals, oldSnapInfo.Name())
s.removePlugsSlots(c, oldSnapInfo)
s.addPlugsSlots(c, newSnapInfo)
err = s.backend.Setup(newSnapInfo, devMode, s.repo)
c.Assert(err, IsNil)
return newSnapInfo
}
func (s *backendSuite) removePlugsSlots(c *C, snapInfo *snap.Info) {
for _, plug := range s.repo.Plugs(snapInfo.Name()) {
err := s.repo.RemovePlug(plug.Snap.Name(), plug.Name)
c.Assert(err, IsNil)
}
for _, slot := range s.repo.Slots(snapInfo.Name()) {
err := s.repo.RemoveSlot(slot.Snap.Name(), slot.Name)
c.Assert(err, IsNil)
}
}
// AddSnap adds plugs and slots declared by the given snap to the repository.
//
// This function can be used to implement snap install or, when used along with
// RemoveSnap, snap upgrade.
//
// AddSnap doesn't change existing plugs/slots. The caller is responsible for
// ensuring that the snap is not present in the repository in any way prior to
// calling this function. If this constraint is violated then no changes are
// made and an error is returned.
//
// Each added plug/slot is validated according to the corresponding interface.
// Unknown interfaces and plugs/slots that don't validate are not added.
// Information about those failures are returned to the caller.
func (r *Repository) AddSnap(snapInfo *snap.Info) error {
r.m.Lock()
defer r.m.Unlock()
snapName := snapInfo.Name()
if r.plugs[snapName] != nil || r.slots[snapName] != nil {
return fmt.Errorf("cannot register interfaces for snap %q more than once", snapName)
}
bad := BadInterfacesError{
snap: snapName,
issues: make(map[string]string),
}
for plugName, plugInfo := range snapInfo.Plugs {
iface, ok := r.ifaces[plugInfo.Interface]
if !ok {
bad.issues[plugName] = "unknown interface"
continue
}
plug := &Plug{PlugInfo: plugInfo}
if err := iface.SanitizePlug(plug); err != nil {
bad.issues[plugName] = err.Error()
continue
}
if r.plugs[snapName] == nil {
r.plugs[snapName] = make(map[string]*Plug)
}
r.plugs[snapName][plugName] = plug
}
for slotName, slotInfo := range snapInfo.Slots {
iface, ok := r.ifaces[slotInfo.Interface]
if !ok {
bad.issues[slotName] = "unknown interface"
continue
}
slot := &Slot{SlotInfo: slotInfo}
if err := iface.SanitizeSlot(slot); err != nil {
bad.issues[slotName] = err.Error()
continue
}
if r.slots[snapName] == nil {
r.slots[snapName] = make(map[string]*Slot)
}
r.slots[snapName][slotName] = slot
}
if len(bad.issues) > 0 {
return &bad
}
return nil
}
// snapDataDirs returns the list of data directories for the given snap version
func snapDataDirs(snap *snap.Info) ([]string, error) {
// collect the directories, homes first
found, err := filepath.Glob(snap.DataHomeDir())
if err != nil {
return nil, err
}
// then system data
found = append(found, snap.DataDir())
return found, nil
}
func removePackageDesktopFiles(s *snap.Info) error {
glob := filepath.Join(dirs.SnapDesktopFilesDir, s.Name()+"_*.desktop")
activeDesktopFiles, err := filepath.Glob(glob)
if err != nil {
return fmt.Errorf("cannot get desktop files for %v: %s", glob, err)
}
for _, f := range activeDesktopFiles {
os.Remove(f)
}
return nil
}
func CopyData(newSnap, oldSnap *snap.Info, flags InstallFlags, meter progress.Meter) error {
dataDir := newSnap.DataDir()
// deal with the old data or
// otherwise just create a empty data dir
if oldSnap == nil {
return os.MkdirAll(dataDir, 0755)
}
return copySnapData(oldSnap, newSnap)
}
func (f *fakeSnappyBackend) CopySnapData(newInfo, oldInfo *snap.Info, flags int) error {
old := "<no-old>"
if oldInfo != nil {
old = oldInfo.MountDir()
}
f.ops = append(f.ops, fakeOp{
op: "copy-data",
name: newInfo.MountDir(),
flags: flags,
old: old,
})
return nil
}
func (f *fakeSnappyBackend) CheckSnap(snapFilePath string, curInfo *snap.Info, flags int) error {
cur := "<no-current>"
if curInfo != nil {
cur = curInfo.MountDir()
}
f.ops = append(f.ops, fakeOp{
op: "check-snap",
name: snapFilePath,
old: cur,
flags: flags,
})
return nil
}
func installRemote(mStore *store.SnapUbuntuStoreRepository, remoteSnap *snap.Info, flags InstallFlags, meter progress.Meter) (string, error) {
downloadedSnap, err := mStore.Download(remoteSnap, meter, nil)
if err != nil {
return "", fmt.Errorf("cannot download %s: %s", remoteSnap.Name(), err)
}
defer os.Remove(downloadedSnap)
localSnap, err := (&Overlord{}).InstallWithSideInfo(downloadedSnap, &remoteSnap.SideInfo, flags, meter)
if err != nil {
return "", err
}
return localSnap.Name(), nil
}
// updateSnap "updates" an existing snap from YAML.
func (s *backendSuite) updateSnap(c *C, oldSnapInfo *snap.Info, devMode bool, snapYaml string, revision int) *snap.Info {
newSnapInfo, err := snap.InfoFromSnapYaml([]byte(snapYaml))
c.Assert(err, IsNil)
newSnapInfo.Revision = revision
// this won't come from snap.yaml
newSnapInfo.Developer = "acme"
c.Assert(newSnapInfo.Name(), Equals, oldSnapInfo.Name())
err = s.repo.RemoveSnap(oldSnapInfo.Name())
c.Assert(err, IsNil)
err = s.repo.AddSnap(newSnapInfo)
c.Assert(err, IsNil)
err = s.backend.Setup(newSnapInfo, devMode, s.repo)
c.Assert(err, IsNil)
return newSnapInfo
}
func doUpdate(mStore *store.SnapUbuntuStoreRepository, rsnap *snap.Info, flags InstallFlags, meter progress.Meter) error {
_, err := installRemote(mStore, rsnap, flags, meter)
if err == ErrSideLoaded {
logger.Noticef("Skipping sideloaded package: %s", rsnap.Name())
return nil
} else if err != nil {
return err
}
if err := GarbageCollect(rsnap.Name(), flags, meter); err != nil {
return err
}
return nil
}
// Copy all data for oldSnap to newSnap
// (but never overwrite)
func copySnapData(oldSnap, newSnap *snap.Info) (err error) {
oldDataDirs, err := snapDataDirs(oldSnap)
if err != nil {
return err
}
newSuffix := filepath.Base(newSnap.DataDir())
for _, oldDir := range oldDataDirs {
// replace the trailing "../$old-suffix" with the "../$new-suffix"
newDir := filepath.Join(filepath.Dir(oldDir), newSuffix)
if err := copySnapDataDirectory(oldDir, newDir); err != nil {
return err
}
}
return nil
}
// Setup creates udev rules specific to a given snap.
// If any of the rules are changed or removed then udev database is reloaded.
//
// Since udev has no concept of a complain mode, devMode is ignored.
//
// If the method fails it should be re-tried (with a sensible strategy) by the caller.
func (b *Backend) Setup(snapInfo *snap.Info, devMode bool, repo *interfaces.Repository) error {
snapName := snapInfo.Name()
snippets, err := repo.SecuritySnippetsForSnap(snapInfo.Name(), interfaces.SecurityUDev)
if err != nil {
return fmt.Errorf("cannot obtain udev security snippets for snap %q: %s", snapName, err)
}
content, err := b.combineSnippets(snapInfo, snippets)
if err != nil {
return fmt.Errorf("cannot obtain expected udev rules for snap %q: %s", snapName, err)
}
glob := fmt.Sprintf("70-%s.rules", interfaces.SecurityTagGlob(snapName))
dir := dirs.SnapUdevRulesDir
if err := os.MkdirAll(dir, 0755); err != nil {
return fmt.Errorf("cannot create directory for udev rules %q: %s", dir, err)
}
return ensureDirState(dir, glob, content, snapName)
}
func CanRemove(s *snap.Info, active bool) bool {
// Gadget snaps should not be removed as they are a key
// building block for Gadgets. Prunning non active ones
// is acceptible.
if s.Type == snap.TypeGadget && active {
return false
}
// You never want to remove an active kernel or OS
if (s.Type == snap.TypeKernel || s.Type == snap.TypeOS) && active {
return false
}
if IsBuiltInSoftware(s.Name()) && active {
return false
}
return true
}
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
}
// SaveManifest saves the manifest at the designated location for the snap containing information not in the snap.yaml.
func SaveManifest(rsnap *snap.Info) error {
if rsnap.Revision == 0 {
return fmt.Errorf("internal error: should not be storring manifests for sideloaded snaps")
}
// XXX: we store OfficialName though it may not be the blessed one later
content, err := yaml.Marshal(&rsnap.SideInfo)
if err != nil {
return err
}
if err := os.MkdirAll(dirs.SnapMetaDir, 0755); err != nil {
return err
}
p := manifestPath(rsnap.Name(), rsnap.Revision)
// don't worry about previous contents
return osutil.AtomicWriteFile(p, content, 0644, 0)
}