func findDownloadPathFromLxdIndex(r io.Reader) (string, error) {
arch := arch.UbuntuArchitecture()
lsb, err := release.ReadLsb()
if err != nil {
return "", err
}
release := lsb.Codename
needle := fmt.Sprintf("ubuntu;%s;%s;default;", release, arch)
scanner := bufio.NewScanner(r)
for scanner.Scan() {
if strings.HasPrefix(scanner.Text(), needle) {
l := strings.Split(scanner.Text(), ";")
if len(l) < 6 {
return "", fmt.Errorf("can not find download path in %s", scanner.Text())
}
return l[5], nil
}
}
if err := scanner.Err(); err != nil {
return "", fmt.Errorf("error while reading the index-system data: %s", err)
}
return "", fmt.Errorf("needle %q not found", needle)
}
// makeSnapHookEnv returns an environment suitable for passing to
// os/exec.Cmd.Env
//
// The returned environment contains additional SNAP_* variables that
// are required when calling a meta/hook/ script and that will override
// any already existing SNAP_* variables in os.Environment()
func makeSnapHookEnv(part *SnapPart) (env []string) {
desc := struct {
AppName string
AppArch string
AppPath string
Version string
UdevAppName string
Origin string
}{
part.Name(),
arch.UbuntuArchitecture(),
part.basedir,
part.Version(),
QualifiedName(part),
part.Origin(),
}
snapEnv := helpers.MakeMapFromEnvList(helpers.GetBasicSnapEnvVars(desc))
// merge regular env and new snapEnv
envMap := helpers.MakeMapFromEnvList(os.Environ())
for k, v := range snapEnv {
envMap[k] = v
}
// flatten
for k, v := range envMap {
env = append(env, fmt.Sprintf("%s=%s", k, v))
}
return env
}
func makeMockLxdIndexSystem() string {
lsb, _ := release.ReadLsb()
arch := arch.UbuntuArchitecture()
s := fmt.Sprintf(`
ubuntu;xenial;otherarch;default;20151126_03:49;/images/ubuntu/xenial/armhf/default/20151126_03:49/
ubuntu;%s;%s;default;20151126_03:49;/images/ubuntu/CODENAME/ARCH/default/20151126_03:49/
`, lsb.Codename, arch)
return s
}
func (s *SnapTestSuite) TestSnappyGenerateSnapBinaryWrapper(c *C) {
binary := Binary{Name: "pastebinit", Exec: "bin/pastebinit"}
pkgPath := "/snaps/pastebinit.mvo/1.4.0.0.1/"
aaProfile := "pastebinit.mvo_pastebinit_1.4.0.0.1"
m := packageYaml{Name: "pastebinit",
Version: "1.4.0.0.1"}
expected := fmt.Sprintf(expectedWrapper, arch.UbuntuArchitecture())
generatedWrapper, err := generateSnapBinaryWrapper(binary, pkgPath, aaProfile, &m)
c.Assert(err, IsNil)
c.Assert(generatedWrapper, Equals, expected)
}
func (s *SnapTestSuite) TestSnappyGenerateSnapBinaryWrapper(c *C) {
pkgPath := "/snap/pastebinit/1.4.0.0.1/"
info := &snap.Info{}
info.SuggestedName = "pastebinit"
info.Version = "1.4.0.0.1"
info.Revision = 44
binary := &snap.AppInfo{
Snap: info,
Name: "pastebinit",
Command: "bin/pastebinit",
}
expected := fmt.Sprintf(expectedWrapper, arch.UbuntuArchitecture())
generatedWrapper, err := generateSnapBinaryWrapper(binary, pkgPath)
c.Assert(err, IsNil)
c.Assert(generatedWrapper, Equals, expected)
}
func info() error {
rel := release.Get()
release := fmt.Sprintf("%s/%s", rel.Flavor, rel.Series)
frameworks, _ := snappy.ActiveSnapIterByType(snappy.FullName, snap.TypeFramework)
apps, _ := snappy.ActiveSnapIterByType(snappy.FullName, snap.TypeApp)
// TRANSLATORS: the %s release string
fmt.Printf(i18n.G("release: %s\n"), release)
// TRANSLATORS: the %s an architecture string
fmt.Printf(i18n.G("architecture: %s\n"), arch.UbuntuArchitecture())
// TRANSLATORS: the %s is a comma separated list of framework names
fmt.Printf(i18n.G("frameworks: %s\n"), strings.Join(frameworks, ", "))
//TRANSLATORS: the %s represents a list of installed appnames
// (e.g. "apps: foo, bar, baz")
fmt.Printf(i18n.G("apps: %s\n"), strings.Join(apps, ", "))
return nil
}
func (s *SnapTestSuite) TestSnappyGenerateSnapBinaryWrapperFmk(c *C) {
binary := Binary{Name: "echo", Exec: "bin/echo"}
pkgPath := "/snaps/fmk/1.4.0.0.1/"
aaProfile := "fmk_echo_1.4.0.0.1"
m := packageYaml{Name: "fmk",
Version: "1.4.0.0.1",
Type: "framework"}
expected := strings.Replace(expectedWrapper, "pastebinit.mvo", "fmk", -1)
expected = strings.Replace(expected, `NAME="pastebinit"`, `NAME="fmk"`, 1)
expected = strings.Replace(expected, "mvo", "", -1)
expected = strings.Replace(expected, "pastebinit", "echo", -1)
expected = fmt.Sprintf(expected, arch.UbuntuArchitecture())
generatedWrapper, err := generateSnapBinaryWrapper(binary, pkgPath, aaProfile, &m)
c.Assert(err, IsNil)
c.Assert(generatedWrapper, Equals, expected)
}
// small helper that sets the correct http headers for the ubuntu store
func (s *SnapUbuntuStoreRepository) applyUbuntuStoreHeaders(req *http.Request, accept string, auther Authenticator) {
if auther != nil {
auther.Authenticate(req)
}
if accept == "" {
accept = "application/hal+json"
}
req.Header.Set("Accept", accept)
req.Header.Set("X-Ubuntu-Architecture", string(arch.UbuntuArchitecture()))
req.Header.Set("X-Ubuntu-Release", release.Get().Series)
req.Header.Set("X-Ubuntu-Wire-Protocol", UbuntuCoreWireProtocol)
if s.storeID != "" {
req.Header.Set("X-Ubuntu-Store", s.storeID)
}
}
// small helper that sets the correct http headers for the ubuntu store
func setUbuntuStoreHeaders(req *http.Request) {
req.Header.Set("Accept", "application/hal+json")
// frameworks
frameworks, _ := ActiveSnapIterByType(BareName, snap.TypeFramework)
req.Header.Set("X-Ubuntu-Frameworks", strings.Join(addCoreFmk(frameworks), ","))
req.Header.Set("X-Ubuntu-Architecture", string(arch.UbuntuArchitecture()))
req.Header.Set("X-Ubuntu-Release", release.String())
req.Header.Set("X-Ubuntu-Wire-Protocol", UbuntuCoreWireProtocol)
if storeID := os.Getenv("UBUNTU_STORE_ID"); storeID != "" {
req.Header.Set("X-Ubuntu-Store", storeID)
} else if storeID := StoreID(); storeID != "" {
req.Header.Set("X-Ubuntu-Store", storeID)
}
// sso
ssoToken, err := ReadStoreToken()
if err == nil {
req.Header.Set("Authorization", oauth.MakePlaintextSignature(&ssoToken.Token))
}
}
// makeSnapHookEnv returns an environment suitable for passing to
// os/exec.Cmd.Env
//
// The returned environment contains additional SNAP_* variables that
// are required when calling a meta/hook/ script and that will override
// any already existing SNAP_* variables in os.Environment()
func makeSnapHookEnv(snap *Snap) (env []string) {
desc := struct {
SnapName string
SnapArch string
SnapPath string
Version string
Revision int
UdevAppName string
}{
snap.Name(),
arch.UbuntuArchitecture(),
snap.Info().MountDir(),
snap.Version(),
snap.Revision(),
snap.Name(),
}
vars := snapenv.GetBasicSnapEnvVars(desc)
snapEnv := snapenv.MakeMapFromEnvList(vars)
// merge regular env and new snapEnv
envMap := snapenv.MakeMapFromEnvList(os.Environ())
for k, v := range snapEnv {
envMap[k] = v
}
// force default locale
envMap["LC_ALL"] = "C.UTF-8"
// flatten
for k, v := range envMap {
env = append(env, fmt.Sprintf("%s=%s", k, v))
}
return env
}
[Service]
ExecStart=/usr/bin/ubuntu-core-launcher app%[2]s aa-profile /apps/app%[2]s/1.0/bin/start
Restart=on-failure
WorkingDirectory=/apps/app%[2]s/1.0/
Environment="SNAP_APP=app_service_1.0" "SNAP=/apps/app%[2]s/1.0/" "SNAP_DATA=/var/lib/apps/app%[2]s/1.0/" "TMPDIR=/tmp/snaps/app%[2]s/1.0/tmp" "TEMPDIR=/tmp/snaps/app%[2]s/1.0/tmp" "SNAP_NAME=app" "SNAP_VERSION=1.0" "SNAP_ORIGIN=%[3]s" "SNAP_FULLNAME=app%[2]s" "SNAP_ARCH=%[5]s" "SNAP_USER_DATA=/root/apps/app%[2]s/1.0/" "SNAP_APP_PATH=/apps/app%[2]s/1.0/" "SNAP_APP_DATA_PATH=/var/lib/apps/app%[2]s/1.0/" "SNAP_APP_TMPDIR=/tmp/snaps/app%[2]s/1.0/tmp" "SNAP_APP_USER_DATA_PATH=/root/apps/app%[2]s/1.0/"
ExecStop=/usr/bin/ubuntu-core-launcher app%[2]s aa-profile /apps/app%[2]s/1.0/bin/stop
ExecStopPost=/usr/bin/ubuntu-core-launcher app%[2]s aa-profile /apps/app%[2]s/1.0/bin/stop --post
TimeoutStopSec=10
%[4]s
[Install]
WantedBy=multi-user.target
`
var (
expectedAppService = fmt.Sprintf(expectedServiceFmt, "After=ubuntu-snappy.frameworks.target\nRequires=ubuntu-snappy.frameworks.target", ".mvo", "mvo", "Type=simple\n", arch.UbuntuArchitecture())
expectedFmkService = fmt.Sprintf(expectedServiceFmt, "Before=ubuntu-snappy.frameworks.target\nAfter=ubuntu-snappy.frameworks-pre.target\nRequires=ubuntu-snappy.frameworks-pre.target", "", "", "Type=simple\n", arch.UbuntuArchitecture())
expectedDbusService = fmt.Sprintf(expectedServiceFmt, "After=ubuntu-snappy.frameworks.target\nRequires=ubuntu-snappy.frameworks.target", ".mvo", "mvo", "Type=dbus\nBusName=foo.bar.baz", arch.UbuntuArchitecture())
// things that need network
expectedNetAppService = fmt.Sprintf(expectedServiceFmt, "After=ubuntu-snappy.frameworks.target\nRequires=ubuntu-snappy.frameworks.target\nAfter=snappy-wait4network.service\nRequires=snappy-wait4network.service", ".mvo", "mvo", "Type=simple\n", arch.UbuntuArchitecture())
expectedNetFmkService = fmt.Sprintf(expectedServiceFmt, "Before=ubuntu-snappy.frameworks.target\nAfter=ubuntu-snappy.frameworks-pre.target\nRequires=ubuntu-snappy.frameworks-pre.target\nAfter=snappy-wait4network.service\nRequires=snappy-wait4network.service", "", "", "Type=simple\n", arch.UbuntuArchitecture())
)
func (s *SystemdTestSuite) TestGenAppServiceFile(c *C) {
desc := &ServiceDescription{
AppName: "app",
ServiceName: "service",
Version: "1.0",
Description: "descr",
func (e *ErrArchitectureNotSupported) Error() string {
return fmt.Sprintf("package's supported architectures (%s) is incompatible with this system (%s)", strings.Join(e.Architectures, ", "), arch.UbuntuArchitecture())
}
func (s *systemd) GenServiceFile(desc *ServiceDescription) string {
serviceTemplate := `[Unit]
Description={{.Description}}
{{if .IsFramework}}Before=ubuntu-snappy.frameworks.target
After=ubuntu-snappy.frameworks-pre.target{{ if .Socket }} {{.SocketFileName}}{{end}}
Requires=ubuntu-snappy.frameworks-pre.target{{ if .Socket }} {{.SocketFileName}}{{end}}{{else}}After=ubuntu-snappy.frameworks.target{{ if .Socket }} {{.SocketFileName}}{{end}}
Requires=ubuntu-snappy.frameworks.target{{ if .Socket }} {{.SocketFileName}}{{end}}{{end}}{{if .IsNetworked}}
After=snappy-wait4network.service
Requires=snappy-wait4network.service{{end}}
X-Snappy=yes
[Service]
ExecStart=/usr/bin/ubuntu-core-launcher {{.UdevAppName}} {{.AaProfile}} {{.FullPathStart}}
Restart={{.Restart}}
WorkingDirectory={{.AppPath}}
Environment="SNAP_APP={{.AppTriple}}" {{.EnvVars}}
{{if .Stop}}ExecStop=/usr/bin/ubuntu-core-launcher {{.UdevAppName}} {{.AaProfile}} {{.FullPathStop}}{{end}}
{{if .PostStop}}ExecStopPost=/usr/bin/ubuntu-core-launcher {{.UdevAppName}} {{.AaProfile}} {{.FullPathPostStop}}{{end}}
{{if .StopTimeout}}TimeoutStopSec={{.StopTimeout.Seconds}}{{end}}
Type={{.Type}}
{{if .BusName}}BusName={{.BusName}}{{end}}
[Install]
WantedBy={{.ServiceSystemdTarget}}
`
var templateOut bytes.Buffer
t := template.Must(template.New("wrapper").Parse(serviceTemplate))
origin := ""
if len(desc.UdevAppName) > len(desc.AppName) {
origin = desc.UdevAppName[len(desc.AppName)+1:]
}
restartCond := desc.Restart.String()
if restartCond == "" {
restartCond = RestartOnFailure.String()
}
wrapperData := struct {
// the service description
ServiceDescription
// and some composed values
FullPathStart string
FullPathStop string
FullPathPostStop string
AppTriple string
ServiceSystemdTarget string
Origin string
AppArch string
Home string
EnvVars string
SocketFileName string
Restart string
Type string
}{
*desc,
filepath.Join(desc.AppPath, desc.Start),
filepath.Join(desc.AppPath, desc.Stop),
filepath.Join(desc.AppPath, desc.PostStop),
fmt.Sprintf("%s_%s_%s", desc.AppName, desc.ServiceName, desc.Version),
servicesSystemdTarget,
origin,
arch.UbuntuArchitecture(),
// systemd runs as PID 1 so %h will not work.
"/root",
"",
desc.SocketFileName,
restartCond,
desc.Type,
}
allVars := helpers.GetBasicSnapEnvVars(wrapperData)
allVars = append(allVars, helpers.GetUserSnapEnvVars(wrapperData)...)
allVars = append(allVars, helpers.GetDeprecatedBasicSnapEnvVars(wrapperData)...)
allVars = append(allVars, helpers.GetDeprecatedUserSnapEnvVars(wrapperData)...)
wrapperData.EnvVars = "\"" + strings.Join(allVars, "\" \"") + "\"" // allVars won't be empty
if err := t.Execute(&templateOut, wrapperData); err != nil {
// this can never happen, except we forget a variable
logger.Panicf("Unable to execute template: %v", err)
}
return templateOut.String()
}
func generateSnapBinaryWrapper(app *AppYaml, pkgPath, aaProfile string, m *snapYaml) (string, error) {
wrapperTemplate := `#!/bin/sh
set -e
# app info (deprecated)
{{.OldAppVars}}
# app info
{{.NewAppVars}}
if [ ! -d "$SNAP_USER_DATA" ]; then
mkdir -p "$SNAP_USER_DATA"
fi
export HOME="$SNAP_USER_DATA"
# export old pwd
export SNAP_OLD_PWD="$(pwd)"
cd {{.AppPath}}
ubuntu-core-launcher {{.UdevAppName}} {{.AaProfile}} {{.Target}} "$@"
`
// it's fine for this to error out; we might be in a framework or sth
origin := originFromBasedir(pkgPath)
if err := verifyAppYaml(app); err != nil {
return "", err
}
actualBinPath := binPathForBinary(pkgPath, app)
udevPartName := m.qualifiedName(origin)
var templateOut bytes.Buffer
t := template.Must(template.New("wrapper").Parse(wrapperTemplate))
wrapperData := struct {
AppName string
AppArch string
AppPath string
Version string
UdevAppName string
Origin string
Home string
Target string
AaProfile string
OldAppVars string
NewAppVars string
}{
AppName: m.Name,
AppArch: arch.UbuntuArchitecture(),
AppPath: pkgPath,
Version: m.Version,
UdevAppName: udevPartName,
Origin: origin,
Home: "$HOME",
Target: actualBinPath,
AaProfile: aaProfile,
}
oldVars := []string{}
for _, envVar := range append(
helpers.GetDeprecatedBasicSnapEnvVars(wrapperData),
helpers.GetDeprecatedUserSnapEnvVars(wrapperData)...) {
oldVars = append(oldVars, quoteEnvVar(envVar))
}
wrapperData.OldAppVars = strings.Join(oldVars, "\n")
newVars := []string{}
for _, envVar := range append(
helpers.GetBasicSnapEnvVars(wrapperData),
helpers.GetUserSnapEnvVars(wrapperData)...) {
newVars = append(newVars, quoteEnvVar(envVar))
}
wrapperData.NewAppVars = strings.Join(newVars, "\n")
t.Execute(&templateOut, wrapperData)
return templateOut.String(), nil
}
func (s *SnapTestSuite) TestErrorOnUnsupportedArchitecture(c *C) {
const packageHello = `name: hello-app
version: 1.10
icon: meta/hello.svg
architectures:
- yadayada
- blahblah
`
snapPkg := makeTestSnapPackage(c, packageHello)
part, err := NewSnapFile(snapPkg, "origin", true)
c.Assert(err, IsNil)
_, err = part.Install(&MockProgressMeter{}, 0)
errorMsg := fmt.Sprintf("package's supported architectures (yadayada, blahblah) is incompatible with this system (%s)", arch.UbuntuArchitecture())
c.Assert(err.Error(), Equals, errorMsg)
}
func generateSnapBinaryWrapper(app *snap.AppInfo, pkgPath string) (string, error) {
wrapperTemplate := `#!/bin/sh
set -e
# snap info
{{.NewAppVars}}
if [ ! -d "$SNAP_USER_DATA" ]; then
mkdir -p "$SNAP_USER_DATA"
fi
export HOME="$SNAP_USER_DATA"
# Snap name is: {{.SnapName}}
# App name is: {{.AppName}}
ubuntu-core-launcher {{.UdevAppName}} {{.AaProfile}} {{.Target}} "$@"
`
if err := snap.ValidateApp(app); err != nil {
return "", err
}
actualBinPath := binPathForBinary(pkgPath, app)
var templateOut bytes.Buffer
t := template.Must(template.New("wrapper").Parse(wrapperTemplate))
wrapperData := struct {
SnapName string
AppName string
SnapArch string
SnapPath string
Version string
Revision int
UdevAppName string
Home string
Target string
AaProfile string
OldAppVars string
NewAppVars string
}{
SnapName: app.Snap.Name(),
AppName: app.Name,
SnapArch: arch.UbuntuArchitecture(),
SnapPath: pkgPath,
Version: app.Snap.Version,
Revision: app.Snap.Revision,
UdevAppName: app.SecurityTag(),
Home: "$HOME",
Target: actualBinPath,
AaProfile: app.SecurityTag(),
}
newVars := []string{}
for _, envVar := range append(
snapenv.GetBasicSnapEnvVars(wrapperData),
snapenv.GetUserSnapEnvVars(wrapperData)...) {
newVars = append(newVars, quoteEnvVar(envVar))
}
wrapperData.NewAppVars = strings.Join(newVars, "\n")
t.Execute(&templateOut, wrapperData)
return templateOut.String(), nil
}
X-Snappy=yes
[Service]
ExecStart=/usr/bin/ubuntu-core-launcher xkcd-webserver%s xkcd-webserver%[2]s_xkcd-webserver_0.3.4 /snaps/xkcd-webserver%[2]s/0.3.4/bin/foo start
Restart=on-failure
WorkingDirectory=/snaps/xkcd-webserver%[2]s/0.3.4/
Environment="SNAP_APP=xkcd-webserver_xkcd-webserver_0.3.4" "SNAP=/snaps/xkcd-webserver%[2]s/0.3.4/" "SNAP_DATA=/var/lib/snaps/xkcd-webserver%[2]s/0.3.4/" "TMPDIR=/tmp/snaps/xkcd-webserver%[2]s/0.3.4/tmp" "TEMPDIR=/tmp/snaps/xkcd-webserver%[2]s/0.3.4/tmp" "SNAP_NAME=xkcd-webserver" "SNAP_VERSION=0.3.4" "SNAP_ORIGIN=%[3]s" "SNAP_FULLNAME=xkcd-webserver%[2]s" "SNAP_ARCH=%[5]s" "SNAP_USER_DATA=%%h/snaps/xkcd-webserver%[2]s/0.3.4/" "SNAP_APP_PATH=/snaps/xkcd-webserver%[2]s/0.3.4/" "SNAP_APP_DATA_PATH=/var/lib/snaps/xkcd-webserver%[2]s/0.3.4/" "SNAP_APP_TMPDIR=/tmp/snaps/xkcd-webserver%[2]s/0.3.4/tmp" "SNAP_APP_USER_DATA_PATH=%%h/snaps/xkcd-webserver%[2]s/0.3.4/"
ExecStop=/usr/bin/ubuntu-core-launcher xkcd-webserver%[2]s xkcd-webserver%[2]s_xkcd-webserver_0.3.4 /snaps/xkcd-webserver%[2]s/0.3.4/bin/foo stop
ExecStopPost=/usr/bin/ubuntu-core-launcher xkcd-webserver%[2]s xkcd-webserver%[2]s_xkcd-webserver_0.3.4 /snaps/xkcd-webserver%[2]s/0.3.4/bin/foo post-stop
TimeoutStopSec=30
%[4]s
[Install]
WantedBy=multi-user.target
`
expectedServiceAppWrapper = fmt.Sprintf(expectedServiceWrapperFmt, "After=ubuntu-snappy.frameworks.target\nRequires=ubuntu-snappy.frameworks.target", ".canonical", "canonical", "\n", arch.UbuntuArchitecture())
expectedNetAppWrapper = fmt.Sprintf(expectedServiceWrapperFmt, "After=ubuntu-snappy.frameworks.target\nRequires=ubuntu-snappy.frameworks.target\nAfter=snappy-wait4network.service\nRequires=snappy-wait4network.service", ".canonical", "canonical", "\n", arch.UbuntuArchitecture())
expectedServiceFmkWrapper = fmt.Sprintf(expectedServiceWrapperFmt, "Before=ubuntu-snappy.frameworks.target\nAfter=ubuntu-snappy.frameworks-pre.target\nRequires=ubuntu-snappy.frameworks-pre.target", "", "", "BusName=foo.bar.baz\nType=dbus", arch.UbuntuArchitecture())
expectedSocketUsingWrapper = fmt.Sprintf(expectedServiceWrapperFmt, "After=ubuntu-snappy.frameworks.target xkcd-webserver_xkcd-webserver_0.3.4.socket\nRequires=ubuntu-snappy.frameworks.target xkcd-webserver_xkcd-webserver_0.3.4.socket", ".canonical", "canonical", "\n", arch.UbuntuArchitecture())
expectedTypeForkingFmkWrapper = fmt.Sprintf(expectedServiceWrapperFmt, "After=ubuntu-snappy.frameworks.target\nRequires=ubuntu-snappy.frameworks.target", ".canonical", "canonical", "Type=forking\n", arch.UbuntuArchitecture())
)
func (s *SnapTestSuite) TestSnappyGenerateSnapServiceTypeForking(c *C) {
service := ServiceYaml{
Name: "xkcd-webserver",
Start: "bin/foo start",
Stop: "bin/foo stop",
PostStop: "bin/foo post-stop",
StopTimeout: timeout.DefaultTimeout,
Description: "A fun webserver",
Forking: true,
X-Snappy=yes
[Service]
ExecStart=/usr/bin/ubuntu-core-launcher snap.xkcd-webserver.xkcd-webserver snap.xkcd-webserver.xkcd-webserver /snap/xkcd-webserver/0.3.4/bin/foo start
Restart=on-failure
WorkingDirectory=/var/snap/xkcd-webserver/0.3.4/
Environment="SNAP=/snap/xkcd-webserver/0.3.4/" "SNAP_DATA=/var/snap/xkcd-webserver/0.3.4/" "SNAP_NAME=xkcd-webserver" "SNAP_VERSION=0.3.4" "SNAP_REVISION=44" "SNAP_ARCH=%[3]s" "SNAP_LIBRARY_PATH=/var/lib/snapd/lib/gl:" "SNAP_USER_DATA=/root/snap/xkcd-webserver/0.3.4/"
ExecStop=/usr/bin/ubuntu-core-launcher snap.xkcd-webserver.xkcd-webserver snap.xkcd-webserver.xkcd-webserver /snap/xkcd-webserver/0.3.4/bin/foo stop
ExecStopPost=/usr/bin/ubuntu-core-launcher snap.xkcd-webserver.xkcd-webserver snap.xkcd-webserver.xkcd-webserver /snap/xkcd-webserver/0.3.4/bin/foo post-stop
TimeoutStopSec=30
%[2]s
[Install]
WantedBy=multi-user.target
`
expectedServiceAppWrapper = fmt.Sprintf(expectedServiceWrapperFmt, "After=snapd.frameworks.target\nRequires=snapd.frameworks.target", "Type=simple\n", arch.UbuntuArchitecture())
expectedServiceFmkWrapper = fmt.Sprintf(expectedServiceWrapperFmt, "Before=snapd.frameworks.target\nAfter=snapd.frameworks-pre.target\nRequires=snapd.frameworks-pre.target", "Type=dbus\nBusName=foo.bar.baz", arch.UbuntuArchitecture())
expectedSocketUsingWrapper = fmt.Sprintf(expectedServiceWrapperFmt, "After=snapd.frameworks.target snap.xkcd-webserver.xkcd-webserver.socket\nRequires=snapd.frameworks.target snap.xkcd-webserver.xkcd-webserver.socket", "Type=simple\n", arch.UbuntuArchitecture())
expectedTypeForkingFmkWrapper = fmt.Sprintf(expectedServiceWrapperFmt, "After=snapd.frameworks.target\nRequires=snapd.frameworks.target", "Type=forking\n", arch.UbuntuArchitecture())
)
func (s *SnapTestSuite) TestSnappyGenerateSnapServiceTypeForking(c *C) {
service := &snap.AppInfo{
Snap: &snap.Info{
SuggestedName: "xkcd-webserver",
Version: "0.3.4",
SideInfo: snap.SideInfo{Revision: 44},
},
Name: "xkcd-webserver",
Command: "bin/foo start",
Stop: "bin/foo stop",
[Service]
ExecStart=/usr/bin/ubuntu-core-launcher app aa-profile /apps/app/1.0/bin/start
Restart=on-failure
WorkingDirectory=/var/apps/app/1.0/
Environment="SNAP=/apps/app/1.0/" "SNAP_DATA=/var/apps/app/1.0/" "SNAP_NAME=app" "SNAP_VERSION=1.0" "SNAP_REVISION=44" "SNAP_ARCH=%[3]s" "SNAP_LIBRARY_PATH=/var/lib/snapd/lib/gl:" "SNAP_USER_DATA=/root/apps/app/1.0/"
ExecStop=/usr/bin/ubuntu-core-launcher app aa-profile /apps/app/1.0/bin/stop
ExecStopPost=/usr/bin/ubuntu-core-launcher app aa-profile /apps/app/1.0/bin/stop --post
TimeoutStopSec=10
%[2]s
[Install]
WantedBy=multi-user.target
`
var (
expectedAppService = fmt.Sprintf(expectedServiceFmt, "After=snapd.frameworks.target\nRequires=snapd.frameworks.target", "Type=simple\n", arch.UbuntuArchitecture())
expectedDbusService = fmt.Sprintf(expectedServiceFmt, "After=snapd.frameworks.target\nRequires=snapd.frameworks.target", "Type=dbus\nBusName=foo.bar.baz", arch.UbuntuArchitecture())
)
func (s *SystemdTestSuite) TestGenAppServiceFile(c *C) {
desc := &ServiceDescription{
SnapName: "app",
AppName: "service",
Version: "1.0",
Revision: 44,
Description: "descr",
SnapPath: "/apps/app/1.0/",
Start: "bin/start",
Stop: "bin/stop",
PostStop: "bin/stop --post",
func (s *SnapTestSuite) TestErrorOnUnsupportedArchitecture(c *C) {
const packageHello = `name: hello-snap
version: 1.10
architectures:
- yadayada
- blahblah
`
snapPkg := makeTestSnapPackage(c, packageHello)
_, err := s.overlord.Install(snapPkg, 0, &MockProgressMeter{})
errorMsg := fmt.Sprintf("package's supported architectures (yadayada, blahblah) is incompatible with this system (%s)", arch.UbuntuArchitecture())
c.Assert(err.Error(), Equals, errorMsg)
}
