Merge lp:~mvo/snappy/15.04-services into lp:~snappy-dev/snappy/15.04-deprecated

[Michael Vogt]

Backport snappy service command and helpers for the REST API.

Unmerged revisions

482. By Michael Vogt on 2015-09-14

cherry pick -r649..650 from lp:snappy

481. By Michael Vogt on 2015-09-14

cherry pick -r 608..609 of lp:snappy

480. By Michael Vogt on 2015-09-14

cherry pick -r600..601 of lp:snappy to merge snappy services command

=== added file 'cmd/snappy/cmd_service.go'
--- cmd/snappy/cmd_service.go	1970-01-01 00:00:00 +0000
+++ cmd/snappy/cmd_service.go	2015-09-14 14:13:47 +0000
@@ -0,0 +1,178 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+
+	"launchpad.net/snappy/helpers"
+	"launchpad.net/snappy/i18n"
+	"launchpad.net/snappy/logger"
+	"launchpad.net/snappy/priv"
+	"launchpad.net/snappy/progress"
+	"launchpad.net/snappy/snappy"
+)
+
+type cmdService struct {
+	Status  svcStatus  `command:"status"`
+	Start   svcStart   `command:"start"`
+	Stop    svcStop    `command:"stop"`
+	Restart svcRestart `command:"restart"`
+	Logs    svcLogs    `command:"logs"`
+}
+
+type svcBase struct {
+	Args struct {
+		Snap    string `positional-arg-name:"snap"`
+		Service string `positional-arg-name:"service"`
+	} `positional-args:"yes"`
+}
+
+type svcStatus struct{ svcBase }
+type svcStart struct{ svcBase }
+type svcStop struct{ svcBase }
+type svcRestart struct{ svcBase }
+type svcLogs struct{ svcBase }
+
+func init() {
+	_, err := parser.AddCommand("service",
+		i18n.G("Query and modify snappy services"),
+		i18n.G("Query and modify snappy services of locally-installed packages"),
+		&cmdService{})
+
+	if err != nil {
+		logger.LogAndPanic(err)
+	}
+
+}
+
+const (
+	doStatus = iota
+	doStart
+	doStop
+	doRestart
+	doLogs
+)
+
+func (s *svcBase) doExecute(cmd int) ([]string, error) {
+	actor, err := snappy.FindServices(s.Args.Snap, s.Args.Service, progress.MakeProgressBar(""))
+	if err != nil {
+		return nil, err
+	}
+
+	switch cmd {
+	case doStatus:
+		return actor.Status()
+	case doLogs:
+		return actor.Loglines()
+	case doStart:
+		return nil, actor.Start()
+	case doStop:
+		return nil, actor.Stop()
+	case doRestart:
+		return nil, actor.Restart()
+	default:
+		panic("can't happen")
+	}
+}
+
+func (s *svcStatus) Execute(args []string) error {
+	stati, err := s.doExecute(doStatus)
+	if err != nil {
+		return err
+	}
+
+	w := tabwriter.NewWriter(os.Stdout, 0, 8, 1, '\t', 0)
+
+	ws, _ := helpers.GetTermWinsize()
+	rows := int(ws.Row) - 2
+
+	header := i18n.G("Snap\tService\tState")
+
+	for i, status := range stati {
+		// print a header every $rows rows if rows is bigger
+		// than 10; otherwise, just the once. 10 is arbitrary,
+		// but the thinking is that on the one hand you don't
+		// want to be using up too much space with headers on
+		// really small terminals and on the other rows might
+		// actually be negative if you're not on a tty.
+		if i%rows == 0 && (i == 0 || rows > 10) {
+			fmt.Fprintln(w, header)
+		}
+		fmt.Fprintln(w, status)
+	}
+	w.Flush()
+
+	return err
+}
+
+func (s *svcLogs) Execute([]string) error {
+	privMutex := priv.New()
+	if err := privMutex.TryLock(); err != nil {
+		return err
+	}
+	defer privMutex.Unlock()
+
+	logs, err := s.doExecute(doLogs)
+	if err != nil {
+		return err
+	}
+
+	for i := range logs {
+		fmt.Println(logs[i])
+	}
+
+	return nil
+}
+
+func (s *svcStart) Execute(args []string) error {
+	privMutex := priv.New()
+	if err := privMutex.TryLock(); err != nil {
+		return err
+	}
+	defer privMutex.Unlock()
+
+	_, err := s.doExecute(doStart)
+	return err
+}
+
+func (s *svcStop) Execute(args []string) error {
+	privMutex := priv.New()
+	if err := privMutex.TryLock(); err != nil {
+		return err
+	}
+	defer privMutex.Unlock()
+
+	_, err := s.doExecute(doStop)
+	return err
+}
+
+func (s *svcRestart) Execute(args []string) error {
+	privMutex := priv.New()
+	if err := privMutex.TryLock(); err != nil {
+		return err
+	}
+	defer privMutex.Unlock()
+
+	_, err := s.doExecute(doRestart)
+	return err
+}

=== added file 'helpers/winsize.go'
--- helpers/winsize.go	1970-01-01 00:00:00 +0000
+++ helpers/winsize.go	2015-09-14 14:13:47 +0000
@@ -0,0 +1,48 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package helpers
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+// Winsize is from tty_ioctl(4)
+type Winsize struct {
+	Row    uint16
+	Col    uint16
+	xpixel uint16 // unused
+	Ypixel uint16 // unused
+}
+
+// GetTermWinsize performs the TIOCGWINSZ ioctl on stdout
+func GetTermWinsize() (*Winsize, error) {
+	ws := &Winsize{}
+	x, _, errno := syscall.Syscall(syscall.SYS_IOCTL, uintptr(syscall.Stdout), uintptr(syscall.TIOCGWINSZ), uintptr(unsafe.Pointer(ws)))
+
+	if int(x) == -1 {
+		// returning ws on error lets people that don't care
+		// about the error get on with querying the struct
+		// (which will be empty on error).
+		return ws, errno
+	}
+
+	return ws, nil
+}

=== added directory 'i18n'
=== added file 'i18n/dummy.go'
--- i18n/dummy.go	1970-01-01 00:00:00 +0000
+++ i18n/dummy.go	2015-09-14 14:13:47 +0000
@@ -0,0 +1,25 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package i18n
+
+// dummy implementation
+func G(s string) string {
+	return s
+}

=== added directory 'po'
=== modified file 'snappy/build.go'
--- snappy/build.go	2015-05-07 08:28:03 +0000
+++ snappy/build.go	2015-09-14 14:13:47 +0000
@@ -144,7 +144,7 @@
 		return err
 	}
 
-	for _, v := range m.Services {
+	for _, v := range m.ServiceYamls {
 		hookName := filepath.Base(v.Name)
 
 		if _, ok := m.Integration[hookName]; !ok {

=== modified file 'snappy/click.go'
--- snappy/click.go	2015-09-11 19:56:16 +0000
+++ snappy/click.go	2015-09-14 14:13:47 +0000
@@ -496,11 +496,11 @@
 	return nil
 }
 
-func verifyServiceYaml(service Service) error {
+func verifyServiceYaml(service ServiceYaml) error {
 	return verifyStructStringsAgainstWhitelist(service, servicesBinariesStringsWhitelist)
 }
 
-func generateSnapServicesFile(service Service, baseDir string, aaProfile string, m *packageYaml) (string, error) {
+func generateSnapServicesFile(service ServiceYaml, baseDir string, aaProfile string, m *packageYaml) (string, error) {
 	if err := verifyServiceYaml(service); err != nil {
 		return "", err
 	}
@@ -537,7 +537,7 @@
 		}), nil
 }
 
-func generateSnapSocketFile(service Service, baseDir string, aaProfile string, m *packageYaml) (string, error) {
+func generateSnapSocketFile(service ServiceYaml, baseDir string, aaProfile string, m *packageYaml) (string, error) {
 	if err := verifyServiceYaml(service); err != nil {
 		return "", err
 	}
@@ -554,21 +554,21 @@
 		}), nil
 }
 
-func generateServiceFileName(m *packageYaml, service Service) string {
+func generateServiceFileName(m *packageYaml, service ServiceYaml) string {
 	return filepath.Join(snapServicesDir, fmt.Sprintf("%s_%s_%s.service", m.Name, service.Name, m.Version))
 }
 
-func generateBusPolicyFileName(m *packageYaml, service Service) string {
+func generateBusPolicyFileName(m *packageYaml, service ServiceYaml) string {
 	return filepath.Join(snapBusPolicyDir, fmt.Sprintf("%s_%s_%s.conf", m.Name, service.Name, m.Version))
 }
 
-func generateSocketFileName(m *packageYaml, service Service) string {
+func generateSocketFileName(m *packageYaml, service ServiceYaml) string {
 	return filepath.Join(snapServicesDir, fmt.Sprintf("%s_%s_%s.socket", m.Name, service.Name, m.Version))
 }
 
 // takes a directory and removes the global root, this is needed
 // when the SetRoot option is used and we need to generate
-// content for the "Services" and "Binaries" section
+// content for the "ServiceYamls" and "Binaries" section
 var stripGlobalRootDir = stripGlobalRootDirImpl
 
 func stripGlobalRootDirImpl(dir string) string {
@@ -594,7 +594,7 @@
 		return err
 	}
 
-	for _, service := range m.Services {
+	for _, service := range m.ServiceYamls {
 		aaProfile, err := getSecurityProfile(m, service.Name, baseDir)
 		if err != nil {
 			return err
@@ -687,7 +687,7 @@
 		return err
 	}
 	sysd := systemd.New(globalRootDir, inter)
-	for _, service := range m.Services {
+	for _, service := range m.ServiceYamls {
 		serviceName := filepath.Base(generateServiceFileName(m, service))
 		if err := sysd.Disable(serviceName); err != nil {
 			return err
@@ -718,7 +718,7 @@
 	}
 
 	// only reload if we actually had services
-	if len(m.Services) > 0 {
+	if len(m.ServiceYamls) > 0 {
 		if err := sysd.DaemonReload(); err != nil {
 			return err
 		}
@@ -795,7 +795,7 @@
 	//       done via the click hooks but we really want to generate
 	//       it all here
 
-	for _, svc := range m.Services {
+	for _, svc := range m.ServiceYamls {
 		if err := addOneSecurityPolicy(m, svc.Name, svc.SecurityDefinitions, baseDir); err != nil {
 			return err
 		}
@@ -825,7 +825,7 @@
 
 func (m *packageYaml) removeSecurityPolicy(baseDir string) error {
 	// TODO: move apparmor policy removal here
-	for _, service := range m.Services {
+	for _, service := range m.ServiceYamls {
 		if err := removeOneSecurityPolicy(m, service.Name, baseDir); err != nil {
 			return err
 		}
@@ -1135,7 +1135,7 @@
 			if !dep.IsActive() {
 				continue
 			}
-			for _, svc := range dep.Services() {
+			for _, svc := range dep.ServiceYamls() {
 				serviceName := filepath.Base(generateServiceFileName(dep.m, svc))
 				timeout := time.Duration(svc.StopTimeout)
 				if err = sysd.Stop(serviceName, timeout); err != nil {

=== modified file 'snappy/click_test.go'
--- snappy/click_test.go	2015-09-11 19:56:16 +0000
+++ snappy/click_test.go	2015-09-14 14:13:47 +0000
@@ -1208,7 +1208,7 @@
 )
 
 func (s *SnapTestSuite) TestSnappyGenerateSnapServiceTypeForking(c *C) {
-	service := Service{
+	service := ServiceYaml{
 		Name:        "xkcd-webserver",
 		Start:       "bin/foo start",
 		Stop:        "bin/foo stop",
@@ -1228,7 +1228,7 @@
 }
 
 func (s *SnapTestSuite) TestSnappyGenerateSnapServiceAppWrapper(c *C) {
-	service := Service{
+	service := ServiceYaml{
 		Name:        "xkcd-webserver",
 		Start:       "bin/foo start",
 		Stop:        "bin/foo stop",
@@ -1247,7 +1247,7 @@
 }
 
 func (s *SnapTestSuite) TestSnappyGenerateSnapServiceAppWrapperWithExternalPort(c *C) {
-	service := Service{
+	service := ServiceYaml{
 		Name:        "xkcd-webserver",
 		Start:       "bin/foo start",
 		Stop:        "bin/foo stop",
@@ -1267,7 +1267,7 @@
 }
 
 func (s *SnapTestSuite) TestSnappyGenerateSnapServiceFmkWrapper(c *C) {
-	service := Service{
+	service := ServiceYaml{
 		Name:        "xkcd-webserver",
 		Start:       "bin/foo start",
 		Stop:        "bin/foo stop",
@@ -1290,7 +1290,7 @@
 }
 
 func (s *SnapTestSuite) TestSnappyGenerateSnapServiceWrapperWhitelist(c *C) {
-	service := Service{Name: "xkcd-webserver",
+	service := ServiceYaml{Name: "xkcd-webserver",
 		Start:       "bin/foo start",
 		Stop:        "bin/foo stop",
 		PostStop:    "bin/foo post-stop",
@@ -1307,23 +1307,23 @@
 }
 
 func (s *SnapTestSuite) TestServiceWhitelistSimple(c *C) {
-	c.Assert(verifyServiceYaml(Service{Name: "foo"}), IsNil)
-	c.Assert(verifyServiceYaml(Service{Description: "foo"}), IsNil)
-	c.Assert(verifyServiceYaml(Service{Start: "foo"}), IsNil)
-	c.Assert(verifyServiceYaml(Service{Stop: "foo"}), IsNil)
-	c.Assert(verifyServiceYaml(Service{PostStop: "foo"}), IsNil)
+	c.Assert(verifyServiceYaml(ServiceYaml{Name: "foo"}), IsNil)
+	c.Assert(verifyServiceYaml(ServiceYaml{Description: "foo"}), IsNil)
+	c.Assert(verifyServiceYaml(ServiceYaml{Start: "foo"}), IsNil)
+	c.Assert(verifyServiceYaml(ServiceYaml{Stop: "foo"}), IsNil)
+	c.Assert(verifyServiceYaml(ServiceYaml{PostStop: "foo"}), IsNil)
 }
 
 func (s *SnapTestSuite) TestServiceWhitelistIllegal(c *C) {
-	c.Assert(verifyServiceYaml(Service{Name: "x\n"}), NotNil)
-	c.Assert(verifyServiceYaml(Service{Description: "foo\n"}), NotNil)
-	c.Assert(verifyServiceYaml(Service{Start: "foo\n"}), NotNil)
-	c.Assert(verifyServiceYaml(Service{Stop: "foo\n"}), NotNil)
-	c.Assert(verifyServiceYaml(Service{PostStop: "foo\n"}), NotNil)
+	c.Assert(verifyServiceYaml(ServiceYaml{Name: "x\n"}), NotNil)
+	c.Assert(verifyServiceYaml(ServiceYaml{Description: "foo\n"}), NotNil)
+	c.Assert(verifyServiceYaml(ServiceYaml{Start: "foo\n"}), NotNil)
+	c.Assert(verifyServiceYaml(ServiceYaml{Stop: "foo\n"}), NotNil)
+	c.Assert(verifyServiceYaml(ServiceYaml{PostStop: "foo\n"}), NotNil)
 }
 
 func (s *SnapTestSuite) TestServiceWhitelistError(c *C) {
-	err := verifyServiceYaml(Service{Name: "x\n"})
+	err := verifyServiceYaml(ServiceYaml{Name: "x\n"})
 	c.Assert(err.Error(), Equals, `services description field 'Name' contains illegal 'x
 ' (legal: '^[A-Za-z0-9/. _#:-]*$')`)
 }
@@ -1545,7 +1545,7 @@
 }
 
 func (s *SnapTestSuite) TestSnappyGenerateSnapSocket(c *C) {
-	service := Service{Name: "xkcd-webserver",
+	service := ServiceYaml{Name: "xkcd-webserver",
 		Start:        "bin/foo start",
 		Description:  "meep",
 		Socket:       true,
@@ -1579,7 +1579,7 @@
 }
 
 func (s *SnapTestSuite) TestSnappyGenerateSnapServiceWithSockte(c *C) {
-	service := Service{
+	service := ServiceYaml{
 		Name:        "xkcd-webserver",
 		Start:       "bin/foo start",
 		Stop:        "bin/foo stop",

=== modified file 'snappy/errors.go'
--- snappy/errors.go	2015-07-06 21:12:34 +0000
+++ snappy/errors.go	2015-09-14 14:13:47 +0000
@@ -29,6 +29,9 @@
 	// ErrPackageNotFound is returned when a snap can not be found
 	ErrPackageNotFound = errors.New("snappy package not found")
 
+	// ErrServiceNotFound is returned when a service can not be found
+	ErrServiceNotFound = errors.New("snappy service not found")
+
 	// ErrNeedRoot is returned when a command needs root privs but
 	// the caller is not root
 	ErrNeedRoot = errors.New("this command requires root access. Please re-run using 'sudo'")

=== modified file 'snappy/parts.go'
--- snappy/parts.go	2015-07-07 02:35:22 +0000
+++ snappy/parts.go	2015-09-14 14:13:47 +0000
@@ -67,8 +67,8 @@
 )
 
 // Services implements snappy packages that offer services
-type Services interface {
-	Services() []Service
+type ServicesYamls interface {
+	Services() []ServiceYaml
 }
 
 // Configuration allows requesting an oem snappy package type's config

=== added file 'snappy/service.go'
--- snappy/service.go	1970-01-01 00:00:00 +0000
+++ snappy/service.go	2015-09-14 14:13:47 +0000
@@ -0,0 +1,183 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package snappy
+
+import (
+	"fmt"
+	"path/filepath"
+	"time"
+
+	"launchpad.net/snappy/i18n"
+	"launchpad.net/snappy/progress"
+	"launchpad.net/snappy/systemd"
+)
+
+type svcT struct {
+	m   *packageYaml
+	svc *ServiceYaml
+}
+
+// A ServiceActor collects the services found by FindServices and lets
+// you perform differnt actions (start, stop, etc) on them.
+type ServiceActor struct {
+	svcs []*svcT
+	pb   progress.Meter
+	sysd systemd.Systemd
+}
+
+// FindServices finds all matching services (empty string matches all)
+// and lets you perform different actions (start, stop, etc) on them.
+//
+// If a snap is specified and no matching snaps are found,
+// ErrPackageNotFound is returned. If a snap is specified and the
+// matching snaps has no matching services, ErrServiceNotFound is
+// returned.
+//
+// If no snap is specified, an empty result is not an error.
+func FindServices(snapName string, serviceName string, pb progress.Meter) (*ServiceActor, error) {
+	var svcs []*svcT
+
+	repo := NewMetaLocalRepository()
+	installed, _ := repo.Installed()
+
+	foundSnap := false
+	for _, part := range installed {
+		snap, ok := part.(*SnapPart)
+		if !ok {
+			// can't happen
+			continue
+		}
+		if snapName != "" && snapName != snap.Name() {
+			continue
+		}
+		foundSnap = true
+
+		yamls := snap.ServiceYamls()
+		for i := range yamls {
+			if serviceName != "" && serviceName != yamls[i].Name {
+				continue
+			}
+			s := &svcT{
+				m:   snap.m,
+				svc: &yamls[i],
+			}
+			svcs = append(svcs, s)
+		}
+	}
+	if snapName != "" {
+		if !foundSnap {
+			return nil, ErrPackageNotFound
+		}
+		if len(svcs) == 0 {
+			return nil, ErrServiceNotFound
+		}
+	}
+
+	return &ServiceActor{
+		svcs: svcs,
+		pb:   pb,
+		sysd: systemd.New(globalRootDir, pb),
+	}, nil
+}
+
+// Status of all the found services.
+func (actor *ServiceActor) Status() ([]string, error) {
+	var stati []string
+	for _, svc := range actor.svcs {
+		svcname := filepath.Base(generateServiceFileName(svc.m, *svc.svc))
+		status, err := actor.sysd.Status(svcname)
+		if err != nil {
+			return nil, err
+		}
+		status = fmt.Sprintf("%s\t%s\t%s", svc.m.Name, svc.svc.Name, status)
+		stati = append(stati, status)
+	}
+
+	return stati, nil
+}
+
+// Start all the found services.
+func (actor *ServiceActor) Start() error {
+	for _, svc := range actor.svcs {
+		svcname := filepath.Base(generateServiceFileName(svc.m, *svc.svc))
+		if err := actor.sysd.Start(svcname); err != nil {
+			// TRANSLATORS: the first %s is the package name, the second is the service name; the %v is the error
+			return fmt.Errorf(i18n.G("unable to start %s's service %s: %v"), svc.m.Name, svc.svc.Name, err)
+		}
+	}
+
+	return nil
+}
+
+// Stop all the found services.
+func (actor *ServiceActor) Stop() error {
+	for _, svc := range actor.svcs {
+		svcname := filepath.Base(generateServiceFileName(svc.m, *svc.svc))
+		if err := actor.sysd.Stop(svcname, time.Duration(svc.svc.StopTimeout)); err != nil {
+			// TRANSLATORS: the first %s is the package name, the second is the service name; the %v is the error
+			return fmt.Errorf(i18n.G("unable to stop %s's service %s: %v"), svc.m.Name, svc.svc.Name, err)
+		}
+	}
+
+	return nil
+}
+
+// Restart all the found services.
+func (actor *ServiceActor) Restart() error {
+	err := actor.Stop()
+	if err != nil {
+		return err
+	}
+
+	return actor.Start()
+}
+
+// Logs for all found services.
+func (actor *ServiceActor) Logs() ([]systemd.Log, error) {
+	var svcnames []string
+
+	for _, svc := range actor.svcs {
+		svcname := filepath.Base(generateServiceFileName(svc.m, *svc.svc))
+		svcnames = append(svcnames, svcname)
+	}
+
+	logs, err := actor.sysd.Logs(svcnames)
+	if err != nil {
+		return nil, fmt.Errorf(i18n.G("unable to get logs: %v"), err)
+	}
+
+	return logs, nil
+}
+
+// Loglines serializes the logs for all found services
+func (actor *ServiceActor) Loglines() ([]string, error) {
+	var lines []string
+
+	logs, err := actor.Logs()
+	if err != nil {
+		return nil, err
+	}
+
+	for i := range logs {
+		lines = append(lines, logs[i].String())
+	}
+
+	return lines, nil
+}

=== added file 'snappy/service_test.go'
--- snappy/service_test.go	1970-01-01 00:00:00 +0000
+++ snappy/service_test.go	2015-09-14 14:13:47 +0000
@@ -0,0 +1,179 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2014-2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package snappy
+
+import (
+	"errors"
+	"os"
+
+	. "gopkg.in/check.v1"
+
+	"launchpad.net/snappy/progress"
+	"launchpad.net/snappy/systemd"
+)
+
+type ServiceActorSuite struct {
+	i      int
+	argses [][]string
+	outs   [][]byte
+	errors []error
+	j      int
+	jsvcs  [][]string
+	jouts  [][]byte
+	jerrs  []error
+	pb     progress.Meter
+}
+
+var _ = Suite(&ServiceActorSuite{})
+
+// borrowed from systemd_test
+func (s *ServiceActorSuite) myRun(args ...string) (out []byte, err error) {
+	s.argses = append(s.argses, args)
+	if s.i < len(s.outs) {
+		out = s.outs[s.i]
+	}
+	if s.i < len(s.errors) {
+		err = s.errors[s.i]
+	}
+	s.i++
+	return out, err
+}
+func (s *ServiceActorSuite) myJctl(svcs []string) (out []byte, err error) {
+	s.jsvcs = append(s.jsvcs, svcs)
+
+	if s.j < len(s.jouts) {
+		out = s.jouts[s.j]
+	}
+	if s.j < len(s.jerrs) {
+		err = s.jerrs[s.j]
+	}
+	s.j++
+
+	return out, err
+}
+
+func (s *ServiceActorSuite) SetUpTest(c *C) {
+	// force UTC timezone, for reproducible timestamps
+	os.Setenv("TZ", "")
+
+	SetRootDir(c.MkDir())
+	systemd.SystemctlCmd = s.myRun
+	systemd.JournalctlCmd = s.myJctl
+	makeInstalledMockSnap(globalRootDir, "")
+	s.i = 0
+	s.argses = nil
+	s.errors = nil
+	s.outs = nil
+	s.j = 0
+	s.jsvcs = nil
+	s.jouts = nil
+	s.jerrs = nil
+	s.pb = &MockProgressMeter{}
+}
+
+func (s *ServiceActorSuite) TestFindServicesNoPackages(c *C) {
+	_, err := FindServices("notfound", "", s.pb)
+	c.Check(err, Equals, ErrPackageNotFound)
+}
+
+func (s *ServiceActorSuite) TestFindServicesNoPackagesNoPattern(c *C) {
+	// tricky way of hiding the installed package ;)
+	SetRootDir(c.MkDir())
+	actor, err := FindServices("", "", s.pb)
+	c.Check(err, IsNil)
+	c.Assert(actor, NotNil)
+	c.Check(actor.svcs, HasLen, 0)
+}
+
+func (s *ServiceActorSuite) TestFindServicesNoServices(c *C) {
+	_, err := FindServices("hello-app", "notfound", s.pb)
+	c.Check(err, Equals, ErrServiceNotFound)
+}
+
+func (s *ServiceActorSuite) TestFindServicesFindsServices(c *C) {
+	actor, err := FindServices("", "", s.pb)
+	c.Assert(err, IsNil)
+	c.Assert(actor, NotNil)
+	c.Check(actor.svcs, HasLen, 1)
+
+	s.outs = [][]byte{
+		nil, // for the "stop"
+		[]byte("ActiveState=inactive\n"),
+		nil, // for the "start"
+		nil, // for the "stop"
+		[]byte("ActiveState=inactive\n"),
+		nil, // for the "start"
+		[]byte("Id=x\nLoadState=loaded\nActiveState=active\nSubState=running\n"), // status
+	}
+	s.errors = []error{
+		nil, nil, // stop & check
+		nil,           // start
+		nil, nil, nil, // restart (== stop & start)
+		nil,                // status
+		&systemd.Timeout{}, // flag
+	}
+	s.jerrs = nil
+	s.jouts = [][]byte{
+		[]byte(`{"foo": "bar", "baz": 42}`),                    // for the Logs call
+		[]byte(`{"__REALTIME_TIMESTAMP":"42","MESSAGE":"hi"}`), // for the Loglines call
+	}
+
+	c.Check(actor.Stop(), IsNil)
+	c.Check(actor.Start(), IsNil)
+	c.Check(actor.Restart(), IsNil)
+	status, err := actor.Status()
+	c.Check(err, IsNil)
+	c.Assert(status, HasLen, 1)
+	c.Check(status[0], Equals, "hello-app\tsvc1\tloaded; active (running)")
+
+	logs, err := actor.Logs()
+	c.Check(err, IsNil)
+	c.Check(logs, DeepEquals, []systemd.Log{{"foo": "bar", "baz": 42.}})
+	lines, err := actor.Loglines()
+	c.Check(err, IsNil)
+	c.Check(lines, DeepEquals, []string{"1970-01-01T00:00:00.000042Z - hi"})
+}
+
+func (s *ServiceActorSuite) TestFindServicesReportsErrors(c *C) {
+	actor, err := FindServices("", "", s.pb)
+	c.Assert(err, IsNil)
+	c.Assert(actor, NotNil)
+	c.Check(actor.svcs, HasLen, 1)
+
+	anError := errors.New("error")
+
+	s.errors = []error{
+		anError, // stop
+		anError, // start
+		anError, // restart
+		anError, // status
+	}
+	s.jerrs = []error{anError, anError}
+
+	c.Check(actor.Stop(), NotNil)
+	c.Check(actor.Start(), NotNil)
+	c.Check(actor.Restart(), NotNil)
+	_, err = actor.Status()
+	c.Check(err, NotNil)
+	_, err = actor.Logs()
+	c.Check(err, NotNil)
+	_, err = actor.Loglines()
+	c.Check(err, NotNil)
+}

=== modified file 'snappy/snapp.go'
--- snappy/snapp.go	2015-09-11 19:56:16 +0000
+++ snappy/snapp.go	2015-09-14 14:13:47 +0000
@@ -72,7 +72,7 @@
 }
 
 // Port is used to declare the Port and Negotiable status of such port
-// that is bound to a Service.
+// that is bound to a ServiceYaml.
 type Port struct {
 	Port       string `yaml:"port,omitempty"`
 	Negotiable bool   `yaml:"negotiable,omitempty"`
@@ -135,8 +135,8 @@
 	return false
 }
 
-// Service represents a service inside a SnapPart
-type Service struct {
+// ServiceYaml represents a service inside a SnapPart
+type ServiceYaml struct {
 	Name        string `yaml:"name" json:"name,omitempty"`
 	Description string `yaml:"description,omitempty" json:"description,omitempty"`
 
@@ -199,8 +199,8 @@
 	DeprecatedFramework string   `yaml:"framework,omitempty"`
 	Frameworks          []string `yaml:"frameworks,omitempty"`
 
-	Services []Service `yaml:"services,omitempty"`
-	Binaries []Binary  `yaml:"binaries,omitempty"`
+	ServiceYamls []ServiceYaml `yaml:"services,omitempty"`
+	Binaries     []Binary      `yaml:"binaries,omitempty"`
 
 	// oem snap only
 	OEM    OEM          `yaml:"oem,omitempty"`
@@ -305,7 +305,7 @@
 			return nil, err
 		}
 	}
-	for _, service := range m.Services {
+	for _, service := range m.ServiceYamls {
 		if err := verifyServiceYaml(service); err != nil {
 			return nil, err
 		}
@@ -322,9 +322,9 @@
 		}
 	}
 
-	for i := range m.Services {
-		if m.Services[i].StopTimeout == 0 {
-			m.Services[i].StopTimeout = DefaultTimeout
+	for i := range m.ServiceYamls {
+		if m.ServiceYamls[i].StopTimeout == 0 {
+			m.ServiceYamls[i].StopTimeout = DefaultTimeout
 		}
 	}
 
@@ -336,7 +336,7 @@
 	for _, bin := range m.Binaries {
 		d[bin.Name] = struct{}{}
 	}
-	for _, svc := range m.Services {
+	for _, svc := range m.ServiceYamls {
 		if _, ok := d[svc.Name]; ok {
 			return ErrNameClash(svc.Name)
 		}
@@ -605,12 +605,12 @@
 	return st.ModTime()
 }
 
-// Services return a list of Service the package declares
-func (s *SnapPart) Services() []Service {
-	return s.m.Services
+// ServiceYamls return a list of ServiceYamls the package declares
+func (s *SnapPart) ServiceYamls() []ServiceYaml {
+	return s.m.ServiceYamls
 }
 
-// Binaries return a list of Service the package declares
+// Binaries return a list of BinaryDescription the package declares
 func (s *SnapPart) Binaries() []Binary {
 	return s.m.Binaries
 }
@@ -740,7 +740,7 @@
 func (s *SnapPart) RequestAppArmorUpdate(policies, templates map[string]bool) error {
 
 	fullName := Dirname(s)
-	for _, svc := range s.Services() {
+	for _, svc := range s.ServiceYamls() {
 		if svc.NeedsAppArmorUpdate(policies, templates) {
 			if err := updateAppArmorJSONTimestamp(fullName, svc.Name, s.Version()); err != nil {
 				return err

=== modified file 'snappy/snapp_test.go'
--- snappy/snapp_test.go	2015-08-02 12:21:07 +0000
+++ snappy/snapp_test.go	2015-09-14 14:13:47 +0000
@@ -146,7 +146,7 @@
 	c.Assert(snap.Version(), Equals, "1.10")
 	c.Assert(snap.IsActive(), Equals, false)
 
-	services := snap.Services()
+	services := snap.ServiceYamls()
 	c.Assert(services, HasLen, 1)
 	c.Assert(services[0].Name, Equals, "svc1")
 
@@ -831,7 +831,7 @@
 	c.Assert(snap.Version(), Equals, "1.10")
 	c.Assert(snap.IsActive(), Equals, false)
 
-	services := snap.Services()
+	services := snap.ServiceYamls()
 	c.Assert(services, HasLen, 2)
 
 	c.Assert(services[0].Name, Equals, "svc1")
@@ -1025,13 +1025,13 @@
 	m, err := parsePackageYamlData(securityServicePackageYaml)
 	c.Assert(err, IsNil)
 
-	c.Assert(m.Services[0].Name, Equals, "testme-service")
-	c.Assert(m.Services[0].Start, Equals, "bin/testme-service.start")
-	c.Assert(m.Services[0].Stop, Equals, "bin/testme-service.stop")
-	c.Assert(m.Services[0].SecurityCaps, HasLen, 2)
-	c.Assert(m.Services[0].SecurityCaps[0], Equals, "networking")
-	c.Assert(m.Services[0].SecurityCaps[1], Equals, "foo_group")
-	c.Assert(m.Services[0].SecurityTemplate, Equals, "foo_template")
+	c.Assert(m.ServiceYamls[0].Name, Equals, "testme-service")
+	c.Assert(m.ServiceYamls[0].Start, Equals, "bin/testme-service.start")
+	c.Assert(m.ServiceYamls[0].Stop, Equals, "bin/testme-service.stop")
+	c.Assert(m.ServiceYamls[0].SecurityCaps, HasLen, 2)
+	c.Assert(m.ServiceYamls[0].SecurityCaps[0], Equals, "networking")
+	c.Assert(m.ServiceYamls[0].SecurityCaps[1], Equals, "foo_group")
+	c.Assert(m.ServiceYamls[0].SecurityTemplate, Equals, "foo_template")
 }
 
 func (s *SnapTestSuite) TestPackageYamlFrameworkParsing(c *C) {
@@ -1287,8 +1287,8 @@
 	}
 	defer func() { timestampUpdater = helpers.UpdateTimestamp }()
 	// if one of the services needs updating, it's updated and returned
-	svc := Service{Name: "svc", SecurityDefinitions: SecurityDefinitions{SecurityTemplate: "foo"}}
-	part := &SnapPart{m: &packageYaml{Name: "part", Services: []Service{svc}, Version: "42"}, namespace: testNamespace}
+	svc := ServiceYaml{Name: "svc", SecurityDefinitions: SecurityDefinitions{SecurityTemplate: "foo"}}
+	part := &SnapPart{m: &packageYaml{Name: "part", ServiceYamls: []ServiceYaml{svc}, Version: "42"}, namespace: testNamespace}
 	err := part.RequestAppArmorUpdate(nil, map[string]bool{"foo": true})
 	c.Assert(err, IsNil)
 	c.Assert(updated, HasLen, 1)
@@ -1318,9 +1318,9 @@
 		return nil
 	}
 	defer func() { timestampUpdater = helpers.UpdateTimestamp }()
-	svc := Service{Name: "svc", SecurityDefinitions: SecurityDefinitions{SecurityTemplate: "foo"}}
+	svc := ServiceYaml{Name: "svc", SecurityDefinitions: SecurityDefinitions{SecurityTemplate: "foo"}}
 	bin := Binary{Name: "echo", SecurityDefinitions: SecurityDefinitions{SecurityTemplate: "foo"}}
-	part := &SnapPart{m: &packageYaml{Services: []Service{svc}, Binaries: []Binary{bin}, Version: "42"}, namespace: testNamespace}
+	part := &SnapPart{m: &packageYaml{ServiceYamls: []ServiceYaml{svc}, Binaries: []Binary{bin}, Version: "42"}, namespace: testNamespace}
 	err := part.RequestAppArmorUpdate(nil, nil)
 	c.Check(err, IsNil)
 	c.Check(updated, HasLen, 0)

=== modified file 'systemd/systemd.go'
--- systemd/systemd.go	2015-09-11 19:56:16 +0000
+++ systemd/systemd.go	2015-09-14 14:13:47 +0000
@@ -19,11 +19,14 @@
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
+	"strconv"
 	"strings"
 	"text/template"
 	"time"
@@ -56,6 +59,26 @@
 // systemctl. It's exported so it can be overridden by testing.
 var SystemctlCmd = run
 
+// jctl calls journalctl to get the JSON logs of the given services, wrapping the error if any.
+func jctl(svcs []string) ([]byte, error) {
+	cmd := []string{"journalctl", "-o", "json"}
+
+	for i := range svcs {
+		cmd = append(cmd, "-u", svcs[i])
+	}
+
+	bs, err := exec.Command(cmd[0], cmd[1:]...).Output() // journalctl can be messy with its stderr
+	if err != nil {
+		exitCode, _ := helpers.ExitCode(err)
+		return nil, &Error{cmd: cmd, exitCode: exitCode, msg: bs}
+	}
+
+	return bs, nil
+}
+
+// JournalctlCmd is called from Logs to run journalctl; exported for testing.
+var JournalctlCmd = jctl
+
 // Systemd exposes a minimal interface to manage systemd via the systemctl command.
 type Systemd interface {
 	DaemonReload() error
@@ -67,8 +90,13 @@
 	Restart(service string, timeout time.Duration) error
 	GenServiceFile(desc *ServiceDescription) string
 	GenSocketFile(desc *ServiceDescription) string
+	Status(service string) (string, error)
+	Logs(services []string) ([]Log, error)
 }
 
+// A Log is a single entry in the systemd journal
+type Log map[string]interface{}
+
 // ServiceDescription describes a snappy systemd service
 type ServiceDescription struct {
 	AppName         string
@@ -151,6 +179,66 @@
 	return err
 }
 
+// Logs for the given service
+func (*systemd) Logs(serviceNames []string) ([]Log, error) {
+	bs, err := JournalctlCmd(serviceNames)
+	if err != nil {
+		return nil, err
+	}
+
+	const noEntries = "-- No entries --\n"
+	if len(bs) == len(noEntries) && string(bs) == noEntries {
+		return nil, nil
+	}
+
+	var logs []Log
+	dec := json.NewDecoder(bytes.NewReader(bs))
+	for {
+		var log Log
+
+		err = dec.Decode(&log)
+		if err != nil {
+			break
+		}
+
+		logs = append(logs, log)
+	}
+
+	if err != io.EOF {
+		return nil, err
+	}
+
+	return logs, nil
+}
+
+var statusregex = regexp.MustCompile(`(?m)^(?:(.*?)=(.*))?$`)
+
+func (s *systemd) Status(serviceName string) (string, error) {
+	bs, err := SystemctlCmd("show", "--property=Id,LoadState,ActiveState,SubState", serviceName)
+	if err != nil {
+		return "", err
+	}
+
+	load, active, sub := "", "", ""
+
+	for _, bs := range statusregex.FindAllSubmatch(bs, -1) {
+		if len(bs[0]) > 0 {
+			k := string(bs[1])
+			v := string(bs[2])
+			switch k {
+			case "LoadState":
+				load = v
+			case "ActiveState":
+				active = v
+			case "SubState":
+				sub = v
+			}
+		}
+	}
+
+	return fmt.Sprintf("%s; %s (%s)", load, active, sub), nil
+}
+
 // Stop the given service, and wait until it has stopped.
 func (s *systemd) Stop(serviceName string, timeout time.Duration) error {
 	if _, err := SystemctlCmd("stop", serviceName); err != nil {
@@ -341,3 +429,33 @@
 	_, isTimeout := err.(*Timeout)
 	return isTimeout
 }
+
+const myFmt = "2006-01-02T15:04:05.000000Z07:00"
+
+func (l Log) String() string {
+	t := "-(no timestamp!)-"
+	if ius, ok := l["__REALTIME_TIMESTAMP"]; ok {
+		// according to systemd.journal-fields(7) it's microseconds as a decimal string
+		sus, ok := ius.(string)
+		if ok {
+			if us, err := strconv.ParseInt(sus, 10, 64); err == nil {
+				t = time.Unix(us/1000000, 1000*(us%1000000)).Format(myFmt)
+			} else {
+				t = fmt.Sprintf("-(timestamp not a decimal number: %#v)-", sus)
+			}
+		} else {
+			t = fmt.Sprintf("-(timestamp not a string: %#v)-", ius)
+		}
+	}
+
+	sid, ok := l["SYSLOG_IDENTIFIER"].(string)
+	if !ok {
+		sid = "-"
+	}
+	msg, ok := l["MESSAGE"].(string)
+	if !ok {
+		msg = "-"
+	}
+
+	return fmt.Sprintf("%s %s %s", t, sid, msg)
+}

=== modified file 'systemd/systemd_test.go'
--- systemd/systemd_test.go	2015-09-01 17:46:30 +0000
+++ systemd/systemd_test.go	2015-09-14 14:13:47 +0000
@@ -46,22 +46,39 @@
 	argses [][]string
 	errors []error
 	outs   [][]byte
-	rep    *testreporter
+
+	j     int
+	jsvcs [][]string
+	jouts [][]byte
+	jerrs []error
+
+	rep *testreporter
 }
 
 var _ = Suite(&SystemdTestSuite{})
 
 func (s *SystemdTestSuite) SetUpTest(c *C) {
+	// force UTC timezone, for reproducible timestamps
+	os.Setenv("TZ", "")
+
 	SystemctlCmd = s.myRun
 	s.i = 0
 	s.argses = nil
 	s.errors = nil
 	s.outs = nil
+
+	JournalctlCmd = s.myJctl
+	s.j = 0
+	s.jsvcs = nil
+	s.jouts = nil
+	s.jerrs = nil
+
 	s.rep = new(testreporter)
 }
 
 func (s *SystemdTestSuite) TearDownTest(c *C) {
 	SystemctlCmd = run
+	JournalctlCmd = jctl
 }
 
 func (s *SystemdTestSuite) myRun(args ...string) (out []byte, err error) {
@@ -76,6 +93,20 @@
 	return out, err
 }
 
+func (s *SystemdTestSuite) myJctl(svcs []string) (out []byte, err error) {
+	s.jsvcs = append(s.jsvcs, svcs)
+
+	if s.j < len(s.jouts) {
+		out = s.jouts[s.j]
+	}
+	if s.j < len(s.jerrs) {
+		err = s.jerrs[s.j]
+	}
+	s.j++
+
+	return out, err
+}
+
 func (s *SystemdTestSuite) errorRun(args ...string) (out []byte, err error) {
 	return nil, &Error{cmd: args, exitCode: 1, msg: []byte("error on error")}
 }
@@ -109,6 +140,16 @@
 	c.Check(s.argses[1], DeepEquals, s.argses[3])
 }
 
+func (s *SystemdTestSuite) TestStatus(c *C) {
+	s.outs = [][]byte{
+		[]byte("Id=Thing\nLoadState=LoadState\nActiveState=ActiveState\nSubState=SubState\n"),
+	}
+	s.errors = []error{nil}
+	out, err := New("", s.rep).Status("foo")
+	c.Assert(err, IsNil)
+	c.Check(out, Equals, "LoadState; ActiveState (SubState)")
+}
+
 func (s *SystemdTestSuite) TestStopTimeout(c *C) {
 	oldSteps := stopSteps
 	oldDelay := stopDelay
@@ -300,3 +341,55 @@
 	c.Check(IsTimeout(os.ErrInvalid), Equals, false)
 	c.Check(IsTimeout(&Timeout{}), Equals, true)
 }
+
+func (s *SystemdTestSuite) TestLogErrJctl(c *C) {
+	s.jerrs = []error{&Timeout{}}
+
+	logs, err := New("", s.rep).Logs([]string{"foo"})
+	c.Check(err, NotNil)
+	c.Check(logs, IsNil)
+	c.Check(s.jsvcs, DeepEquals, [][]string{{"foo"}})
+	c.Check(s.j, Equals, 1)
+}
+
+func (s *SystemdTestSuite) TestLogErrJSON(c *C) {
+	s.jouts = [][]byte{[]byte("this is not valid json.")}
+
+	logs, err := New("", s.rep).Logs([]string{"foo"})
+	c.Check(err, NotNil)
+	c.Check(logs, IsNil)
+	c.Check(s.jsvcs, DeepEquals, [][]string{{"foo"}})
+	c.Check(s.j, Equals, 1)
+}
+
+func (s *SystemdTestSuite) TestLogs(c *C) {
+	s.jouts = [][]byte{[]byte(`{"a": 1}
+{"a": 2}
+`)}
+
+	logs, err := New("", s.rep).Logs([]string{"foo"})
+	c.Check(err, IsNil)
+	c.Check(logs, DeepEquals, []Log{{"a": 1.}, {"a": 2.}})
+	c.Check(s.jsvcs, DeepEquals, [][]string{{"foo"}})
+	c.Check(s.j, Equals, 1)
+}
+
+func (s *SystemdTestSuite) TestLogString(c *C) {
+	c.Check(Log{}.String(), Equals, "-(no timestamp!)- - -")
+	c.Check(Log{
+		"__REALTIME_TIMESTAMP": 42,
+	}.String(), Equals, "-(timestamp not a string: 42)- - -")
+	c.Check(Log{
+		"__REALTIME_TIMESTAMP": "what",
+	}.String(), Equals, "-(timestamp not a decimal number: \"what\")- - -")
+	c.Check(Log{
+		"__REALTIME_TIMESTAMP": "0",
+		"MESSAGE":              "hi",
+	}.String(), Equals, "1970-01-01T00:00:00.000000Z - hi")
+	c.Check(Log{
+		"__REALTIME_TIMESTAMP": "42",
+		"MESSAGE":              "hi",
+		"SYSLOG_IDENTIFIER":    "me",
+	}.String(), Equals, "1970-01-01T00:00:00.000042Z me hi")
+
+}