Merge lp:~elopio/snappy/serve_daemon_test into lp:~snappy-dev/snappy/snappy-moved-to-github

[Leo Arias]

Unmerged revisions

651. By Leo Arias on 2015-09-09

Playing with the daemon.

=== added directory 'cmd/snapd'
=== added file 'cmd/snapd/main.go'
--- cmd/snapd/main.go	1970-01-01 00:00:00 +0000
+++ cmd/snapd/main.go	2015-09-09 06:26:03 +0000
@@ -0,0 +1,73 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 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"
+	"os/signal"
+	"syscall"
+
+	"launchpad.net/snappy/daemon"
+	"launchpad.net/snappy/logger"
+)
+
+func init() {
+	err := logger.SimpleSetup()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "WARNING: failed to activate logging: %s\n", err)
+	}
+}
+
+// XXX what are the alternatives here? use real systemd to run the binary? --elopio- 2015-09-09
+func fixListenPid() {
+	if os.Getenv("FIX_LISTEN_PID") != "" {
+		// HACK: real systemd would set LISTEN_PID before exec'ing but
+		// this is too difficult in golang for the purpose of a test.
+		// Do not do this in real code.
+		os.Setenv("LISTEN_PID", fmt.Sprintf("%d", os.Getpid()))
+	}
+}
+
+func main() {
+	fixListenPid()
+	if err := run(); err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+func run() error {
+	d := daemon.New()
+
+	if err := d.Init(); err != nil {
+		return err
+	}
+
+	ch := make(chan os.Signal)
+	signal.Notify(ch, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM)
+	select {
+	case sig := <-ch:
+		logger.Noticef("Exiting on %s signal.\n", sig)
+	case <-d.Dying():
+	}
+
+	return d.Stop()
+}

=== added file 'cmd/snapd/main_test.go'
--- cmd/snapd/main_test.go	1970-01-01 00:00:00 +0000
+++ cmd/snapd/main_test.go	2015-09-09 06:26:03 +0000
@@ -0,0 +1,50 @@
+package main
+
+import (
+	"io/ioutil"
+	"net"
+	"net/http"
+	"os"
+	"os/exec"
+	"syscall"
+	"testing"
+
+	"gopkg.in/check.v1"
+)
+
+// Hook up check.v1 into the "go test" runner
+func Test(t *testing.T) { check.TestingT(t) }
+
+type snapdSuite struct{}
+
+var _ = check.Suite(&snapdSuite{})
+
+func (s *snapdSuite) Test(c *check.C) {
+	cmd := exec.Command("go", "run", "main.go")
+
+	// TODO get a random port. Not yet because this is useful to know if the server is being killed.
+	// --elopio - 2015-09-09
+	listener, err := net.Listen("tcp", ":9999")
+	c.Assert(err, check.IsNil)
+
+	tcpListener := listener.(*net.TCPListener)
+	f, err := tcpListener.File()
+	c.Assert(err, check.IsNil)
+	cmd.ExtraFiles = []*os.File{f}
+
+	cmd.Env = os.Environ()
+	cmd.Env = append(cmd.Env, "LISTEN_FDS=1", "FIX_LISTEN_PID=1")
+
+	cmd.Start()
+	// FIXME this is not killing the server. How do we get the pid? Close the listener? Close the file?
+	// --elopio - 2015-09-09
+	defer cmd.Process.Signal(syscall.SIGTERM)
+
+	resp, err := http.Get("http://127.0.0.1:9999")
+	defer resp.Body.Close()
+	c.Assert(err, check.IsNil)
+	body, err := ioutil.ReadAll(resp.Body)
+	c.Assert(err, check.IsNil)
+	expected := `{"metadata":["/1.0"],"status":"OK","status_code":200,"type":"sync"}`
+	c.Assert(string(body), check.Equals, expected)
+}

=== added directory 'daemon'
=== added file 'daemon/api.go'
--- daemon/api.go	1970-01-01 00:00:00 +0000
+++ daemon/api.go	2015-09-09 06:26:03 +0000
@@ -0,0 +1,54 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 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 daemon
+
+import (
+	"net/http"
+
+	"launchpad.net/snappy/release"
+	_ "launchpad.net/snappy/snappy" // FIXME: remove this import when it's imported elsewhere (we need the setroot for release)
+)
+
+var api = []*Command{
+	rootCmd,
+	v1Cmd,
+}
+
+var (
+	rootCmd = &Command{
+		Path: "/",
+		GET:  SyncResponse([]string{"/1.0"}).Self,
+	}
+
+	v1Cmd = &Command{
+		Path: "/1.0",
+		GET:  v1Get,
+	}
+)
+
+func v1Get(c *Command, r *http.Request) Response {
+	rel := release.Get()
+	return SyncResponse(map[string]string{
+		"flavor":          rel.Flavor,
+		"release":         rel.Series,
+		"default_channel": rel.Channel,
+		"api_compat":      "0",
+	}).Self(c, r)
+}

=== added file 'daemon/api_test.go'
--- daemon/api_test.go	1970-01-01 00:00:00 +0000
+++ daemon/api_test.go	2015-09-09 06:26:03 +0000
@@ -0,0 +1,123 @@
+// -*- 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 daemon
+
+import (
+	"encoding/json"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io/ioutil"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"gopkg.in/check.v1"
+
+	"launchpad.net/snappy/release"
+)
+
+// Hook up check.v1 into the "go test" runner
+func Test(t *testing.T) { check.TestingT(t) }
+
+type apiSuite struct{}
+
+var _ = check.Suite(&apiSuite{})
+
+func (s *apiSuite) TestListIncludesAll(c *check.C) {
+	// NOTE: there's probably a better/easier way of doing this
+	// (patches welcome)
+
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "api.go", nil, 0)
+	if err != nil {
+		panic(err)
+	}
+
+	found := 0
+
+	ast.Inspect(f, func(n ast.Node) bool {
+		switch v := n.(type) {
+		case *ast.ValueSpec:
+			found += len(v.Values)
+			return false
+		}
+		return true
+	})
+
+	exceptions := []string{"api"}
+	c.Check(found, check.Equals, len(api)+len(exceptions),
+		check.Commentf(`At a glance it looks like you've not added all the Commands defined in api to the api list. If that is not the case, please add the exception to the "exceptions" list in this test.`))
+}
+
+func (s *apiSuite) TestRootCmd(c *check.C) {
+	// check it only does GET
+	c.Check(rootCmd.PUT, check.IsNil)
+	c.Check(rootCmd.POST, check.IsNil)
+	c.Check(rootCmd.DELETE, check.IsNil)
+	c.Assert(rootCmd.GET, check.NotNil)
+
+	rec := httptest.NewRecorder()
+	c.Check(rootCmd.Path, check.Equals, "/")
+
+	rootCmd.GET(rootCmd, nil).Handler(rec, nil)
+	c.Check(rec.Code, check.Equals, 200)
+	c.Check(rec.HeaderMap.Get("Content-Type"), check.Equals, "application/json")
+
+	expected := []interface{}{"/1.0"}
+	var rsp resp
+	c.Assert(json.Unmarshal(rec.Body.Bytes(), &rsp), check.IsNil)
+	c.Check(rsp.Status, check.Equals, 200)
+	c.Check(rsp.Metadata, check.DeepEquals, expected)
+}
+
+func (s *apiSuite) TestV1(c *check.C) {
+	// check it only does GET
+	c.Check(v1Cmd.PUT, check.IsNil)
+	c.Check(v1Cmd.POST, check.IsNil)
+	c.Check(v1Cmd.DELETE, check.IsNil)
+	c.Assert(v1Cmd.GET, check.NotNil)
+
+	rec := httptest.NewRecorder()
+	c.Check(v1Cmd.Path, check.Equals, "/1.0")
+
+	// set up release
+	root := c.MkDir()
+	d := filepath.Join(root, "etc", "system-image")
+	c.Assert(os.MkdirAll(d, 0755), check.IsNil)
+	c.Assert(ioutil.WriteFile(filepath.Join(d, "channel.ini"), []byte("[service]\nchannel: ubuntu-flavor/release/channel"), 0644), check.IsNil)
+	c.Assert(release.Setup(root), check.IsNil)
+
+	v1Cmd.GET(v1Cmd, nil).Handler(rec, nil)
+	c.Check(rec.Code, check.Equals, 200)
+	c.Check(rec.HeaderMap.Get("Content-Type"), check.Equals, "application/json")
+
+	expected := map[string]interface{}{
+		"flavor":          "flavor",
+		"release":         "release",
+		"default_channel": "channel",
+		"api_compat":      "0",
+	}
+	var rsp resp
+	c.Assert(json.Unmarshal(rec.Body.Bytes(), &rsp), check.IsNil)
+	c.Check(rsp.Status, check.Equals, 200)
+	c.Check(rsp.Metadata, check.DeepEquals, expected)
+}

=== added file 'daemon/daemon.go'
--- daemon/daemon.go	1970-01-01 00:00:00 +0000
+++ daemon/daemon.go	2015-09-09 06:26:03 +0000
@@ -0,0 +1,122 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 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 daemon
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"github.com/stgraber/lxd-go-systemd/activation"
+	"gopkg.in/tomb.v2"
+
+	"launchpad.net/snappy/logger"
+)
+
+// A Daemon listens for requests and routes them to the right command
+type Daemon struct {
+	listener net.Listener
+	tomb     tomb.Tomb
+	router   *mux.Router
+}
+
+// A ResponseFunc handles one of the individual verbs for a method
+type ResponseFunc func(*Command, *http.Request) Response
+
+// A Command routes a request to an individual per-verb ResponseFUnc
+type Command struct {
+	Path string
+	//
+	GET    ResponseFunc
+	PUT    ResponseFunc
+	POST   ResponseFunc
+	DELETE ResponseFunc
+	//
+	d *Daemon
+}
+
+func (c *Command) handler(w http.ResponseWriter, r *http.Request) {
+	var rspf ResponseFunc
+	rsp := BadMethod
+
+	switch r.Method {
+	case "GET":
+		rspf = c.GET
+	case "PUT":
+		rspf = c.PUT
+	case "POST":
+		rspf = c.POST
+	case "DELETE":
+		rspf = c.DELETE
+	}
+	if rspf != nil {
+		rsp = rspf(c, r)
+	}
+
+	rsp.Handler(w, r)
+}
+
+// Init sets up the Daemon's internal workings.
+// Don't call more than once.
+func (d *Daemon) Init() error {
+	listeners, err := activation.Listeners(false)
+	if err != nil {
+		return err
+	}
+
+	if len(listeners) != 1 {
+		return fmt.Errorf("daemon does not handler %d listeners right now, just one", len(listeners))
+	}
+
+	d.listener = listeners[0]
+
+	d.router = mux.NewRouter()
+
+	for _, c := range api {
+		c.d = d
+		logger.Debugf("adding %s", c.Path)
+		d.router.HandleFunc(c.Path, c.handler).Name(c.Path)
+	}
+
+	d.router.NotFoundHandler = http.HandlerFunc(NotFound.Handler)
+
+	d.tomb.Go(func() error {
+		return http.Serve(d.listener, d.router)
+	})
+
+	return nil
+}
+
+// Stop shuts down the Daemon
+func (d *Daemon) Stop() error {
+	d.tomb.Kill(nil)
+	return d.tomb.Wait()
+}
+
+// Dying is a tomb-ish thing
+func (d *Daemon) Dying() <-chan struct{} {
+	return d.tomb.Dying()
+}
+
+// New Daemon
+func New() *Daemon {
+	return &Daemon{}
+}

=== added file 'daemon/response.go'
--- daemon/response.go	1970-01-01 00:00:00 +0000
+++ daemon/response.go	2015-09-09 06:26:03 +0000
@@ -0,0 +1,107 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 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 daemon
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"launchpad.net/snappy/logger"
+)
+
+// ResponseType is the response type
+type ResponseType string
+
+// “there are three standard return types: Standard return value,
+// Background operation, Error”, each returning a JSON object with the
+// following “type” field:
+const (
+	ResponseTypeSync  ResponseType = "sync"
+	ResponseTypeAsync              = "async"
+	ResponseTypeError              = "error"
+)
+
+// Response knows how to render itself, how to handle itself, and how to find itself
+type Response interface {
+	Render(w http.ResponseWriter) ([]byte, int)
+	Handler(w http.ResponseWriter, r *http.Request)
+	Self(*Command, *http.Request) Response // has the same arity as ResponseFunc for convenience
+}
+
+type resp struct {
+	Type     ResponseType `json:"type"`
+	Status   int          `json:"status_code"`
+	Metadata interface{}  `json:"metadata"`
+}
+
+func (r *resp) MarshalJSON() ([]byte, error) {
+	return json.Marshal(map[string]interface{}{
+		"type":        r.Type,
+		"status":      http.StatusText(r.Status),
+		"status_code": r.Status,
+		"metadata":    &r.Metadata,
+	})
+}
+
+func (r *resp) Render(w http.ResponseWriter) (buf []byte, status int) {
+	bs, err := r.MarshalJSON()
+	if err != nil {
+		logger.Noticef("unable to marshal %#v to JSON: %v", *r, err)
+		return nil, http.StatusInternalServerError
+	}
+
+	return bs, r.Status
+}
+
+func (r *resp) Handler(w http.ResponseWriter, _ *http.Request) {
+	bs, status := r.Render(w)
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	w.Write(bs)
+}
+
+func (r *resp) Self(*Command, *http.Request) Response {
+	return r
+}
+
+// SyncResponse builds a "sync" response from the given metadata.
+func SyncResponse(metadata interface{}) Response {
+	return &resp{
+		Type:     ResponseTypeSync,
+		Status:   http.StatusOK,
+		Metadata: metadata,
+	}
+}
+
+// ErrorResponse builds an "error" response from the given error status.
+func ErrorResponse(status int) Response {
+	return &resp{
+		Type:   ResponseTypeError,
+		Status: status,
+	}
+}
+
+// standard error responses
+var (
+	NotFound      = ErrorResponse(http.StatusNotFound)
+	BadMethod     = ErrorResponse(http.StatusMethodNotAllowed)
+	InternalError = ErrorResponse(http.StatusInternalServerError)
+)

=== modified file 'po/snappy.pot'
--- po/snappy.pot	2015-09-03 12:20:25 +0000
+++ po/snappy.pot	2015-09-09 06:26:03 +0000
@@ -7,7 +7,7 @@
 msgid   ""
 msgstr  "Project-Id-Version: snappy\n"
         "Report-Msgid-Bugs-To: [e-mail]\n"
-        "POT-Creation-Date: 2015-09-03 13:19+0100\n"
+        "POT-Creation-Date: 2015-09-08 10:46+0100\n"
         "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
         "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
         "Language-Team: LANGUAGE <[e-mail]>\n"

=== modified file 'release/release.go'
--- release/release.go	2015-05-15 13:33:27 +0000
+++ release/release.go	2015-09-09 06:26:03 +0000
@@ -51,6 +51,11 @@
 	return rel.String()
 }
 
+// Get the release
+func Get() Release {
+	return rel
+}
+
 // Override sets up the release using a Release
 func Override(r Release) {
 	rel = r