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

[Michael Vogt]

Add support for systemd socket files.

Backport of the branch that adds systemd socket file generation which is important for docker.

[John Lenton (chipaca)]

review: Approve

=== modified file 'docs/meta.md'
--- docs/meta.md	2015-05-29 13:43:15 +0000
+++ docs/meta.md	2015-09-08 06:48:07 +0000
@@ -70,6 +70,10 @@
     * `bus-name`: (optional) message bus connection name for the service.
       May only be specified for snaps of 'type: framework' (see above). See
       frameworks.md for details.
+    * `socket`: (optional) Set to "true" is the service is socket activated
+    * `listen-stream`: (optional) The full path of the stream socket
+    * `socket-user`: (optional) The user that owns the stream socket
+    * `socket-group`: (optional) The group that own the stream socket
 
 * `binaries`: the binaries (executables) that the snap provides
     * `name`: (required) the name of the binary, the user will be able to

=== modified file 'snappy/click.go'
--- snappy/click.go	2015-09-01 17:46:30 +0000
+++ snappy/click.go	2015-09-08 06:48:07 +0000
@@ -510,22 +510,46 @@
 		return "", err
 	}
 
+	socketFileName := ""
+	if service.Socket {
+		socketFileName = filepath.Base(generateSocketFileName(m, service))
+	}
+
 	return systemd.New(globalRootDir, nil).GenServiceFile(
 		&systemd.ServiceDescription{
-			AppName:     m.Name,
-			ServiceName: service.Name,
-			Version:     m.Version,
-			Description: service.Description,
-			AppPath:     baseDir,
-			Start:       service.Start,
-			Stop:        service.Stop,
-			PostStop:    service.PostStop,
-			StopTimeout: time.Duration(service.StopTimeout),
-			AaProfile:   aaProfile,
-			IsFramework: m.Type == SnapTypeFramework,
-			IsNetworked: service.Ports != nil && len(service.Ports.External) > 0,
-			BusName:     service.BusName,
-			UdevAppName: udevPartName,
+			AppName:        m.Name,
+			ServiceName:    service.Name,
+			Version:        m.Version,
+			Description:    service.Description,
+			AppPath:        baseDir,
+			Start:          service.Start,
+			Stop:           service.Stop,
+			PostStop:       service.PostStop,
+			StopTimeout:    time.Duration(service.StopTimeout),
+			AaProfile:      aaProfile,
+			IsFramework:    m.Type == SnapTypeFramework,
+			IsNetworked:    service.Ports != nil && len(service.Ports.External) > 0,
+			BusName:        service.BusName,
+			UdevAppName:    udevPartName,
+			Socket:         service.Socket,
+			SocketFileName: socketFileName,
+		}), nil
+}
+
+func generateSnapSocketFile(service Service, baseDir string, aaProfile string, m *packageYaml) (string, error) {
+	if err := verifyServiceYaml(service); err != nil {
+		return "", err
+	}
+
+	serviceFileName := filepath.Base(generateServiceFileName(m, service))
+
+	return systemd.New(globalRootDir, nil).GenSocketFile(
+		&systemd.ServiceDescription{
+			ServiceFileName: serviceFileName,
+			ListenStream:    service.ListenStream,
+			SocketMode:      service.SocketMode,
+			SocketUser:      service.SocketUser,
+			SocketGroup:     service.SocketGroup,
 		}), nil
 }
 
@@ -537,6 +561,10 @@
 	return filepath.Join(snapBusPolicyDir, fmt.Sprintf("%s_%s_%s.conf", m.Name, service.Name, m.Version))
 }
 
+func generateSocketFileName(m *packageYaml, service Service) 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
@@ -575,6 +603,7 @@
 		// is in the service file when the SetRoot() option
 		// is used
 		realBaseDir := stripGlobalRootDir(baseDir)
+		// Generate service file
 		content, err := generateSnapServicesFile(service, realBaseDir, aaProfile, m)
 		if err != nil {
 			return err
@@ -584,7 +613,18 @@
 		if err := ioutil.WriteFile(serviceFilename, []byte(content), 0644); err != nil {
 			return err
 		}
-
+		// Generate systemd socket file if needed
+		if service.Socket {
+			content, err := generateSnapSocketFile(service, realBaseDir, aaProfile, m)
+			if err != nil {
+				return err
+			}
+			socketFilename := generateSocketFileName(m, service)
+			os.MkdirAll(filepath.Dir(socketFilename), 0755)
+			if err := ioutil.WriteFile(socketFilename, []byte(content), 0644); err != nil {
+				return err
+			}
+		}
 		// If necessary, generate the DBus policy file so the framework
 		// service is allowed to start
 		if m.Type == SnapTypeFramework && service.BusName != "" {
@@ -621,6 +661,20 @@
 				return err
 			}
 		}
+
+		if service.Socket {
+			socketName := filepath.Base(generateSocketFileName(m, service))
+			// we always enable the socket even in inhibit hooks
+			if err := sysd.Enable(socketName); err != nil {
+				return err
+			}
+
+			if !inhibitHooks {
+				if err := sysd.Start(socketName); err != nil {
+					return err
+				}
+			}
+		}
 	}
 
 	return nil
@@ -652,6 +706,10 @@
 			log.Printf("Warning: failed to remove service file for %s: %v", serviceName, err)
 		}
 
+		if err := os.Remove(generateSocketFileName(m, service)); err != nil && !os.IsNotExist(err) {
+			log.Printf("Failed to remove socket file for %q: %v", serviceName, err)
+		}
+
 		// Also remove DBus system policy file
 		if err := os.Remove(generateBusPolicyFileName(m, service)); err != nil && !os.IsNotExist(err) {
 			log.Printf("Warning: failed to remove bus policy file for service %s: %v", serviceName, err)

=== modified file 'snappy/click_test.go'
--- snappy/click_test.go	2015-09-01 17:46:30 +0000
+++ snappy/click_test.go	2015-09-08 06:48:07 +0000
@@ -1200,9 +1200,10 @@
 [Install]
 WantedBy=multi-user.target
 `
-	expectedServiceAppWrapper = fmt.Sprintf(expectedServiceWrapperFmt, "After=ubuntu-snappy.frameworks.target\nRequires=ubuntu-snappy.frameworks.target", ".canonical", "canonical", "\n", helpers.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", helpers.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", helpers.UbuntuArchitecture())
+	expectedServiceAppWrapper  = fmt.Sprintf(expectedServiceWrapperFmt, "After=ubuntu-snappy.frameworks.target\nRequires=ubuntu-snappy.frameworks.target", ".canonical", "canonical", "\n", helpers.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", helpers.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", helpers.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", helpers.UbuntuArchitecture())
 )
 
 func (s *SnapTestSuite) TestSnappyGenerateSnapServiceAppWrapper(c *C) {
@@ -1521,3 +1522,57 @@
 		exitCode: 1,
 	})
 }
+
+func (s *SnapTestSuite) TestSnappyGenerateSnapSocket(c *C) {
+	service := Service{Name: "xkcd-webserver",
+		Start:        "bin/foo start",
+		Description:  "meep",
+		Socket:       true,
+		ListenStream: "/var/run/docker.sock",
+		SocketMode:   "0660",
+		SocketUser:   "root",
+		SocketGroup:  "adm",
+	}
+	pkgPath := "/apps/xkcd-webserver.canonical/0.3.4/"
+	aaProfile := "xkcd-webserver.canonical_xkcd-webserver_0.3.4"
+	m := packageYaml{
+		Name:    "xkcd-webserver",
+		Version: "0.3.4"}
+
+	content, err := generateSnapSocketFile(service, pkgPath, aaProfile, &m)
+	c.Assert(err, IsNil)
+	c.Assert(content, Equals, `[Unit]
+Description= Socket Unit File
+PartOf=xkcd-webserver_xkcd-webserver_0.3.4.service
+X-Snappy=yes
+
+[Socket]
+ListenStream=/var/run/docker.sock
+SocketMode=0660
+SocketUSer=root
+SocketGroup=adm
+
+[Install]
+WantedBy=sockets.target
+`)
+}
+
+func (s *SnapTestSuite) TestSnappyGenerateSnapServiceWithSockte(c *C) {
+	service := Service{
+		Name:        "xkcd-webserver",
+		Start:       "bin/foo start",
+		Stop:        "bin/foo stop",
+		PostStop:    "bin/foo post-stop",
+		StopTimeout: DefaultTimeout,
+		Description: "A fun webserver",
+		Socket:      true,
+	}
+	pkgPath := "/apps/xkcd-webserver.canonical/0.3.4/"
+	aaProfile := "xkcd-webserver.canonical_xkcd-webserver_0.3.4"
+	m := packageYaml{Name: "xkcd-webserver",
+		Version: "0.3.4"}
+
+	generatedWrapper, err := generateSnapServicesFile(service, pkgPath, aaProfile, &m)
+	c.Assert(err, IsNil)
+	c.Assert(generatedWrapper, Equals, expectedSocketUsingWrapper)
+}

=== modified file 'snappy/snapp.go'
--- snappy/snapp.go	2015-07-07 02:35:22 +0000
+++ snappy/snapp.go	2015-09-08 06:48:07 +0000
@@ -146,6 +146,13 @@
 	StopTimeout Timeout `yaml:"stop-timeout,omitempty" json:"stop-timeout,omitempty"`
 	BusName     string  `yaml:"bus-name,omitempty" json:"bus-name,omitempty"`
 
+	// set to yes if we need to create a systemd socket for this service
+	Socket       bool   `yaml:"socket,omitempty" json:"socket,omitempty"`
+	ListenStream string `yaml:"listen-stream,omitempty" json:"listen-stream,omitempty"`
+	SocketMode   string `yaml:"socket-mode,omitempty" json:"socket-mode,omitempty"`
+	SocketUser   string `yaml:"socket-user,omitempty" json:"socket-user,omitempty"`
+	SocketGroup  string `yaml:"socket-group,omitempty" json:"socket-group,omitempty"`
+
 	// must be a pointer so that it can be "nil" and omitempty works
 	Ports *Ports `yaml:"ports,omitempty" json:"ports,omitempty"`
 

=== modified file 'systemd/systemd.go'
--- systemd/systemd.go	2015-09-01 17:46:30 +0000
+++ systemd/systemd.go	2015-09-08 06:48:07 +0000
@@ -66,30 +66,41 @@
 	Kill(service, signal string) error
 	Restart(service string, timeout time.Duration) error
 	GenServiceFile(desc *ServiceDescription) string
+	GenSocketFile(desc *ServiceDescription) string
 }
 
 // ServiceDescription describes a snappy systemd service
 type ServiceDescription struct {
-	AppName     string
-	ServiceName string
-	Version     string
-	Description string
-	AppPath     string
-	Start       string
-	Stop        string
-	PostStop    string
-	StopTimeout time.Duration
-	AaProfile   string
-	IsFramework bool
-	IsNetworked bool
-	BusName     string
-	UdevAppName string
+	AppName         string
+	ServiceName     string
+	Version         string
+	Description     string
+	AppPath         string
+	Start           string
+	Stop            string
+	PostStop        string
+	StopTimeout     time.Duration
+	AaProfile       string
+	IsFramework     bool
+	IsNetworked     bool
+	BusName         string
+	UdevAppName     string
+	Socket          bool
+	SocketFileName  string
+	ListenStream    string
+	SocketMode      string
+	SocketUser      string
+	SocketGroup     string
+	ServiceFileName string
 }
 
 const (
 	// the default target for systemd units that we generate
 	servicesSystemdTarget = "multi-user.target"
 
+	// the default target for systemd units that we generate
+	socketsSystemdTarget = "sockets.target"
+
 	// the location to put system services
 	snapServicesDir = "/etc/systemd/system"
 )
@@ -173,9 +184,9 @@
 	serviceTemplate := `[Unit]
 Description={{.Description}}
 {{if .IsFramework}}Before=ubuntu-snappy.frameworks.target
-After=ubuntu-snappy.frameworks-pre.target
-Requires=ubuntu-snappy.frameworks-pre.target{{else}}After=ubuntu-snappy.frameworks.target
-Requires=ubuntu-snappy.frameworks.target{{end}}{{if .IsNetworked}}
+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
@@ -213,6 +224,7 @@
 		AppArch              string
 		Home                 string
 		EnvVars              string
+		SocketFileName       string
 	}{
 		*desc,
 		filepath.Join(desc.AppPath, desc.Start),
@@ -224,6 +236,7 @@
 		helpers.UbuntuArchitecture(),
 		"%h",
 		"",
+		desc.SocketFileName,
 	}
 	allVars := helpers.GetBasicSnapEnvVars(wrapperData)
 	allVars = append(allVars, helpers.GetUserSnapEnvVars(wrapperData)...)
@@ -239,6 +252,52 @@
 	return templateOut.String()
 }
 
+func (s *systemd) GenSocketFile(desc *ServiceDescription) string {
+	serviceTemplate := `[Unit]
+Description={{.Description}} Socket Unit File
+PartOf={{.ServiceFileName}}
+X-Snappy=yes
+
+[Socket]
+ListenStream={{.ListenStream}}
+{{if .SocketMode}}SocketMode={{.SocketMode}}{{end}}
+{{if .SocketUser}}SocketUSer={{.SocketUser}}{{end}}
+{{if .SocketGroup}}SocketGroup={{.SocketGroup}}{{end}}
+
+[Install]
+WantedBy={{.SocketSystemdTarget}}
+`
+	var templateOut bytes.Buffer
+	t := template.Must(template.New("wrapper").Parse(serviceTemplate))
+
+	wrapperData := struct {
+		// the service description
+		ServiceDescription
+		// and some composed values
+		ServiceFileName,
+		ListenStream string
+		SocketMode          string
+		SocketUser          string
+		SocketGroup         string
+		SocketSystemdTarget string
+	}{
+		*desc,
+		desc.ServiceFileName,
+		desc.ListenStream,
+		desc.SocketMode,
+		desc.SocketUser,
+		desc.SocketGroup,
+		socketsSystemdTarget,
+	}
+
+	if err := t.Execute(&templateOut, wrapperData); err != nil {
+		// this can never happen, except we forget a variable
+		logger.LogAndPanic(err)
+	}
+
+	return templateOut.String()
+}
+
 // Kill all processes of the unit with the given signal
 func (s *systemd) Kill(serviceName, signal string) error {
 	_, err := SystemctlCmd("kill", serviceName, "-s", signal)