Merge lp:~pedronis/ubuntu-push/server-lego into lp:ubuntu-push

[Samuele Pedroni]

make server/dev into composable pieces, somewhat big mostly because of lots of shuffling around

make server/dev into composable pieces, somewhat big mostly because of lots of shuffling around

probably still needs some moving around in a subsequent branch

[John Lenton (chipaca)]

Lovely! :-)

[John Lenton (chipaca)]

review: Disapprove

[John Lenton (chipaca)]

j/k :-)

review: Approve

=== added file 'server/dev/bootlog.go'
--- server/dev/bootlog.go	1970-01-01 00:00:00 +0000
+++ server/dev/bootlog.go	2014-01-22 09:51:22 +0000
@@ -0,0 +1,35 @@
+/*
+ Copyright 2013-2014 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 warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, 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 (
+	"launchpad.net/ubuntu-push/logger"
+	"net"
+	"os"
+)
+
+// boot logging and hooks
+
+func bootLogListener(kind string, lst net.Listener) {
+	BootLogger.Infof("listening for %s on %v", kind, lst.Addr())
+}
+
+var (
+	BootLogger      = logger.NewSimpleLogger(os.Stderr, "debug")
+	BootLogListener = bootLogListener
+	BootLogFatalf   = BootLogger.Fatalf
+)

=== added file 'server/dev/bootlog_test.go'
--- server/dev/bootlog_test.go	1970-01-01 00:00:00 +0000
+++ server/dev/bootlog_test.go	2014-01-22 09:51:22 +0000
@@ -0,0 +1,45 @@
+/*
+ Copyright 2013-2014 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 warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, 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 (
+	"bytes"
+	. "launchpad.net/gocheck"
+	"launchpad.net/ubuntu-push/logger"
+	"net"
+	"testing"
+)
+
+func TestRunners(t *testing.T) { TestingT(t) }
+
+type bootlogSuite struct{}
+
+var _ = Suite(&bootlogSuite{})
+
+func (s *bootlogSuite) TestBootLogListener(c *C) {
+	buf := &bytes.Buffer{}
+	prevBootLogger := BootLogger
+	BootLogger = logger.NewSimpleLogger(buf, "info")
+	defer func() {
+		BootLogger = prevBootLogger
+	}()
+	lst, err := net.Listen("tcp", "127.0.0.1:0")
+	c.Assert(err, IsNil)
+	defer lst.Close()
+	BootLogListener("client", lst)
+	c.Check(buf.String(), Matches, ".* INFO listening for client on "+lst.Addr().String()+"\n")
+}

=== renamed file 'server/dev/server_test.go' => 'server/dev/config_test.go'
--- server/dev/server_test.go	2014-01-14 15:35:20 +0000
+++ server/dev/config_test.go	2014-01-22 09:51:22 +0000
@@ -17,28 +17,20 @@
 package main
 
 import (
-	// "fmt"
 	"bytes"
 	"io/ioutil"
 	. "launchpad.net/gocheck"
+	"launchpad.net/ubuntu-push/config"
 	"os"
 	"path/filepath"
-	"testing"
 	"time"
 )
 
-func TestDevserver(t *testing.T) { TestingT(t) }
-
-type devserverSuite struct{}
-
-var _ = Suite(&devserverSuite{})
-
-func (s *devserverSuite) TestConfigRead(c *C) {
-	tmpDir := c.MkDir()
-	err := ioutil.WriteFile(filepath.Join(tmpDir, "key.key"), []byte("KeY"), os.ModePerm)
-	c.Assert(err, IsNil)
-	err = ioutil.WriteFile(filepath.Join(tmpDir, "cert.cert"), []byte("CeRt"), os.ModePerm)
-	c.Assert(err, IsNil)
+type configSuite struct{}
+
+var _ = Suite(&configSuite{})
+
+func (s *configSuite) TestDevicesParsedConfig(c *C) {
 	buf := bytes.NewBufferString(`{
 "ping_interval": "5m",
 "exchange_timeout": "10s",
@@ -46,60 +38,34 @@
 "broker_queue_size": 100,
 "addr": "127.0.0.1:9999",
 "key_pem_file": "key.key",
-"cert_pem_file": "cert.cert",
-"http_addr": "127.0.0.1:8080",
-"http_read_timeout": "5s",
-"http_write_timeout": "10s"
+"cert_pem_file": "cert.cert"
 }`)
-	cfg := &configuration{}
-	err = cfg.read(buf, tmpDir)
+	cfg := &DevicesParsedConfig{}
+	err := config.ReadConfig(buf, cfg)
 	c.Assert(err, IsNil)
 	c.Check(cfg.PingInterval(), Equals, 5*time.Minute)
 	c.Check(cfg.ExchangeTimeout(), Equals, 10*time.Second)
 	c.Check(cfg.BrokerQueueSize(), Equals, uint(100))
 	c.Check(cfg.SessionQueueSize(), Equals, uint(10))
 	c.Check(cfg.Addr(), Equals, "127.0.0.1:9999")
+}
+
+func (s *configSuite) TestDevicesParsedConfigLoadFinish(c *C) {
+	tmpDir := c.MkDir()
+	cfg := &DevicesParsedConfig{
+		ParsedKeyPEMFile:  "key.key",
+		ParsedCertPEMFile: "cert.cert",
+	}
+	err := cfg.FinishLoad(tmpDir)
+	c.Check(err, ErrorMatches, "reading key_pem_file:.*no such file.*")
+	err = ioutil.WriteFile(filepath.Join(tmpDir, "key.key"), []byte("KeY"), os.ModePerm)
+	c.Assert(err, IsNil)
+	err = cfg.FinishLoad(tmpDir)
+	c.Check(err, ErrorMatches, "reading cert_pem_file:.*no such file.*")
+	err = ioutil.WriteFile(filepath.Join(tmpDir, "cert.cert"), []byte("CeRt"), os.ModePerm)
+	c.Assert(err, IsNil)
+	err = cfg.FinishLoad(tmpDir)
+	c.Assert(err, IsNil)
 	c.Check(string(cfg.KeyPEMBlock()), Equals, "KeY")
 	c.Check(string(cfg.CertPEMBlock()), Equals, "CeRt")
-	c.Check(cfg.HTTPAddr(), Equals, "127.0.0.1:8080")
-	c.Check(cfg.HTTPReadTimeout(), Equals, 5*time.Second)
-	c.Check(cfg.HTTPWriteTimeout(), Equals, 10*time.Second)
-}
-
-func (s *devserverSuite) TestConfigReadErrors(c *C) {
-	tmpDir := c.MkDir()
-	checkError := func(config, expectedErr string) {
-		cfg := &configuration{}
-		err := cfg.read(bytes.NewBufferString(config), tmpDir)
-		c.Check(err, ErrorMatches, expectedErr)
-	}
-	checkError("", "EOF")
-	checkError(`{"ping_interval": "1m"}`, "missing exchange_timeout")
-	checkError(`{"ping_interval": "1m", "exchange_timeout": "5s", "session_queue_size": "foo"}`, "session_queue_size:.*type uint")
-	checkError(`{
-"exchange_timeout": "10s",
-"ping_interval": "5m",
-"broker_queue_size": 100,
-"session_queue_size": 10,
-"addr": ":9000",
-"key_pem_file": "doesntexist",
-"cert_pem_file": "doesntexist",
-"http_addr": ":8080",
-"http_read_timeout": "5s",
-"http_write_timeout": "10s"
-}`, "reading key_pem_file:.*no such file.*")
-	err := ioutil.WriteFile(filepath.Join(tmpDir, "key.key"), []byte("KeY"), os.ModePerm)
-	c.Assert(err, IsNil)
-	checkError(`{
-"exchange_timeout": "10s",
-"ping_interval": "5m",
-"broker_queue_size": 100,
-"session_queue_size": 10,
-"addr": ":9000",
-"key_pem_file": "key.key",
-"cert_pem_file": "doesntexist",
-"http_addr": ":8080",
-"http_read_timeout": "5s",
-"http_write_timeout": "10s"
-}`, "reading cert_pem_file:.*no such file.*")
 }

=== renamed file 'server/dev/config.go' => 'server/dev/runner_devices.go'
--- server/dev/config.go	2014-01-14 15:35:20 +0000
+++ server/dev/runner_devices.go	2014-01-22 09:51:22 +0000
@@ -18,89 +18,37 @@
 
 import (
 	"fmt"
-	"io"
 	"launchpad.net/ubuntu-push/config"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/server/listener"
+	"net"
+	"syscall"
 	"time"
 )
 
-// expectedConfiguration is used as target for JSON parsing the configuration.
-type expectedConfiguration struct {
+// A DevicesParsedConfig holds and can be used to parse the device server config.
+type DevicesParsedConfig struct {
 	// session configuration
-	PingInterval    config.ConfigTimeDuration `json:"ping_interval"`
-	ExchangeTimeout config.ConfigTimeDuration `json:"exchange_timeout"`
+	ParsedPingInterval    config.ConfigTimeDuration `json:"ping_interval"`
+	ParsedExchangeTimeout config.ConfigTimeDuration `json:"exchange_timeout"`
 	// broker configuration
-	SessionQueueSize config.ConfigQueueSize `json:"session_queue_size"`
-	BrokerQueueSize  config.ConfigQueueSize `json:"broker_queue_size"`
+	ParsedSessionQueueSize config.ConfigQueueSize `json:"session_queue_size"`
+	ParsedBrokerQueueSize  config.ConfigQueueSize `json:"broker_queue_size"`
 	// device listener configuration
-	Addr        config.ConfigHostPort `json:"addr"`
-	KeyPEMFile  string                `json:"key_pem_file"`
-	CertPEMFile string                `json:"cert_pem_file"`
-	// api http server configuration
-	HTTPAddr         config.ConfigHostPort     `json:"http_addr"`
-	HTTPReadTimeout  config.ConfigTimeDuration `json:"http_read_timeout"`
-	HTTPWriteTimeout config.ConfigTimeDuration `json:"http_write_timeout"`
-}
-
-// configuration holds the server configuration and gives it access
-// through the various component config interfaces.
-type configuration struct {
-	parsed       expectedConfiguration
+	ParsedAddr        config.ConfigHostPort `json:"addr"`
+	ParsedKeyPEMFile  string                `json:"key_pem_file"`
+	ParsedCertPEMFile string                `json:"cert_pem_file"`
+	// private post-processed config
 	certPEMBlock []byte
 	keyPEMBlock  []byte
 }
 
-func (cfg *configuration) PingInterval() time.Duration {
-	return cfg.parsed.PingInterval.TimeDuration()
-}
-
-func (cfg *configuration) ExchangeTimeout() time.Duration {
-	return cfg.parsed.ExchangeTimeout.TimeDuration()
-}
-
-func (cfg *configuration) SessionQueueSize() uint {
-	return cfg.parsed.SessionQueueSize.QueueSize()
-}
-
-func (cfg *configuration) BrokerQueueSize() uint {
-	return cfg.parsed.BrokerQueueSize.QueueSize()
-}
-
-func (cfg *configuration) Addr() string {
-	return cfg.parsed.Addr.HostPort()
-}
-
-func (cfg *configuration) KeyPEMBlock() []byte {
-	return cfg.keyPEMBlock
-}
-
-func (cfg *configuration) CertPEMBlock() []byte {
-	return cfg.certPEMBlock
-}
-
-func (cfg *configuration) HTTPAddr() string {
-	return cfg.parsed.HTTPAddr.HostPort()
-}
-
-func (cfg *configuration) HTTPReadTimeout() time.Duration {
-	return cfg.parsed.HTTPReadTimeout.TimeDuration()
-}
-
-func (cfg *configuration) HTTPWriteTimeout() time.Duration {
-	return cfg.parsed.HTTPWriteTimeout.TimeDuration()
-}
-
-// read reads & parses configuration from the reader. it uses baseDir
-// to load mentioned files in the configuration.
-func (cfg *configuration) read(r io.Reader, baseDir string) error {
-	err := config.ReadConfig(r, &cfg.parsed)
-	if err != nil {
-		return err
-	}
-	keyPEMBlock, err := config.LoadFile(cfg.parsed.KeyPEMFile, baseDir)
+func (cfg *DevicesParsedConfig) FinishLoad(baseDir string) error {
+	keyPEMBlock, err := config.LoadFile(cfg.ParsedKeyPEMFile, baseDir)
 	if err != nil {
 		return fmt.Errorf("reading key_pem_file: %v", err)
 	}
-	certPEMBlock, err := config.LoadFile(cfg.parsed.CertPEMFile, baseDir)
+	certPEMBlock, err := config.LoadFile(cfg.ParsedCertPEMFile, baseDir)
 	if err != nil {
 		return fmt.Errorf("reading cert_pem_file: %v", err)
 	}
@@ -108,3 +56,53 @@
 	cfg.certPEMBlock = certPEMBlock
 	return nil
 }
+
+func (cfg *DevicesParsedConfig) PingInterval() time.Duration {
+	return cfg.ParsedPingInterval.TimeDuration()
+}
+
+func (cfg *DevicesParsedConfig) ExchangeTimeout() time.Duration {
+	return cfg.ParsedExchangeTimeout.TimeDuration()
+}
+
+func (cfg *DevicesParsedConfig) SessionQueueSize() uint {
+	return cfg.ParsedSessionQueueSize.QueueSize()
+}
+
+func (cfg *DevicesParsedConfig) BrokerQueueSize() uint {
+	return cfg.ParsedBrokerQueueSize.QueueSize()
+}
+
+func (cfg *DevicesParsedConfig) Addr() string {
+	return cfg.ParsedAddr.HostPort()
+}
+
+func (cfg *DevicesParsedConfig) KeyPEMBlock() []byte {
+	return cfg.keyPEMBlock
+}
+
+func (cfg *DevicesParsedConfig) CertPEMBlock() []byte {
+	return cfg.certPEMBlock
+}
+
+// RunDevices listens for device connections.
+func DevicesRunner(session func(net.Conn) error, logger logger.Logger, parsedCfg *DevicesParsedConfig) func() {
+	BootLogger.Debugf("PingInterval: %s, ExchangeTimeout %s", parsedCfg.PingInterval(), parsedCfg.ExchangeTimeout())
+	var rlim syscall.Rlimit
+	err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlim)
+	if err != nil {
+		BootLogFatalf("getrlimit failed: %v", err)
+	}
+	BootLogger.Debugf("nofile soft: %d hard: %d", rlim.Cur, rlim.Max)
+	lst, err := listener.DeviceListen(parsedCfg)
+	if err != nil {
+		BootLogFatalf("start device listening: %v", err)
+	}
+	BootLogListener("devices", lst)
+	return func() {
+		err = lst.AcceptLoop(session, logger)
+		if err != nil {
+			BootLogFatalf("accepting device connections: %v", err)
+		}
+	}
+}

=== renamed file 'server/dev/http.go' => 'server/dev/runner_http.go'
--- server/dev/http.go	2014-01-14 15:35:20 +0000
+++ server/dev/runner_http.go	2014-01-22 09:51:22 +0000
@@ -17,24 +17,34 @@
 package main
 
 import (
+	"launchpad.net/ubuntu-push/config"
 	"net"
 	"net/http"
-	"time"
 )
 
-// A HTTPServeConfig holds the HTTP server config.
-type HTTPServeConfig interface {
-	HTTPAddr() string
-	HTTPReadTimeout() time.Duration
-	HTTPWriteTimeout() time.Duration
+// A HTTPServeParsedConfig holds and can be used to parse the HTTP server config.
+type HTTPServeParsedConfig struct {
+	ParsedHTTPAddr         config.ConfigHostPort     `json:"http_addr"`
+	ParsedHTTPReadTimeout  config.ConfigTimeDuration `json:"http_read_timeout"`
+	ParsedHTTPWriteTimeout config.ConfigTimeDuration `json:"http_write_timeout"`
 }
 
-// RunHTTPServe serves HTTP requests.
-func RunHTTPServe(lst net.Listener, h http.Handler, cfg HTTPServeConfig) error {
+// HTTPServeRunner returns a function to serve HTTP requests.
+func HTTPServeRunner(h http.Handler, parsedCfg *HTTPServeParsedConfig) func() {
+	httpLst, err := net.Listen("tcp", parsedCfg.ParsedHTTPAddr.HostPort())
+	if err != nil {
+		BootLogFatalf("start http listening: %v", err)
+	}
+	BootLogListener("http", httpLst)
 	srv := &http.Server{
 		Handler:      h,
-		ReadTimeout:  cfg.HTTPReadTimeout(),
-		WriteTimeout: cfg.HTTPReadTimeout(),
-	}
-	return srv.Serve(lst)
+		ReadTimeout:  parsedCfg.ParsedHTTPReadTimeout.TimeDuration(),
+		WriteTimeout: parsedCfg.ParsedHTTPWriteTimeout.TimeDuration(),
+	}
+	return func() {
+		err := srv.Serve(httpLst)
+		if err != nil {
+			BootLogFatalf("accepting http connections: %v", err)
+		}
+	}
 }

=== renamed file 'server/dev/http_test.go' => 'server/dev/runner_test.go'
--- server/dev/http_test.go	2014-01-14 15:35:20 +0000
+++ server/dev/runner_test.go	2014-01-22 09:51:22 +0000
@@ -17,54 +17,100 @@
 package main
 
 import (
+	"bytes"
 	"fmt"
 	"io/ioutil"
 	. "launchpad.net/gocheck"
-	// "log"
+	"launchpad.net/ubuntu-push/config"
+	"launchpad.net/ubuntu-push/logger"
+	helpers "launchpad.net/ubuntu-push/testing"
 	"net"
 	"net/http"
 	"time"
 )
 
-type httpSuite struct{}
-
-var _ = Suite(&httpSuite{})
-
-type testHTTPServeConfig struct{}
-
-func (cfg testHTTPServeConfig) HTTPAddr() string {
-	return "127.0.0.1:0"
-}
-
-func (cfg testHTTPServeConfig) HTTPReadTimeout() time.Duration {
-	return 5 * time.Second
-}
-
-func (cfg testHTTPServeConfig) HTTPWriteTimeout() time.Duration {
-	return 5 * time.Second
+type runnerSuite struct {
+	prevBootLogListener func(string, net.Listener)
+	prevBootLogFatalf   func(string, ...interface{})
+	lst                 net.Listener
+	kind                string
+}
+
+var _ = Suite(&runnerSuite{})
+
+func (s *runnerSuite) SetUpSuite(c *C) {
+	s.prevBootLogFatalf = BootLogFatalf
+	s.prevBootLogListener = BootLogListener
+	BootLogFatalf = func(format string, v ...interface{}) {
+		panic(fmt.Sprintf(format, v...))
+	}
+	BootLogListener = func(kind string, lst net.Listener) {
+		s.kind = kind
+		s.lst = lst
+	}
+}
+
+func (s *runnerSuite) TearDownSuite(c *C) {
+	BootLogListener = s.prevBootLogListener
+	BootLogFatalf = s.prevBootLogFatalf
+}
+
+var testHTTPServeParsedConfig = HTTPServeParsedConfig{
+	"127.0.0.1:0",
+	config.ConfigTimeDuration{5 * time.Second},
+	config.ConfigTimeDuration{5 * time.Second},
 }
 
 func testHandle(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprintf(w, "yay!\n")
 }
 
-func (s *httpSuite) TestRunHTTPServe(c *C) {
-	cfg := testHTTPServeConfig{}
-	lst, err := net.Listen("tcp", cfg.HTTPAddr())
-	c.Assert(err, IsNil)
-	defer lst.Close()
-	errCh := make(chan error, 1)
+func (s *runnerSuite) TestHTTPServeRunner(c *C) {
+	errCh := make(chan interface{}, 1)
 	h := http.HandlerFunc(testHandle)
+	runner := HTTPServeRunner(h, &testHTTPServeParsedConfig)
+	c.Assert(s.lst, Not(IsNil))
+	defer s.lst.Close()
+	c.Check(s.kind, Equals, "http")
 	go func() {
-		errCh <- RunHTTPServe(lst, h, cfg)
+		defer func() {
+			errCh <- recover()
+		}()
+		runner()
 	}()
-	resp, err := http.Get(fmt.Sprintf("http://%s/", lst.Addr()))
+	resp, err := http.Get(fmt.Sprintf("http://%s/", s.lst.Addr()))
 	c.Assert(err, IsNil)
 	defer resp.Body.Close()
 	c.Assert(resp.StatusCode, Equals, 200)
 	body, err := ioutil.ReadAll(resp.Body)
 	c.Assert(err, IsNil)
 	c.Check(string(body), Equals, "yay!\n")
-	lst.Close()
-	c.Check(<-errCh, ErrorMatches, ".*closed.*")
+	s.lst.Close()
+	c.Check(<-errCh, Matches, "accepting http connections:.*closed.*")
+}
+
+var testDevicesParsedConfig = DevicesParsedConfig{
+	ParsedPingInterval:     config.ConfigTimeDuration{60 * time.Second},
+	ParsedExchangeTimeout:  config.ConfigTimeDuration{10 * time.Second},
+	ParsedBrokerQueueSize:  config.ConfigQueueSize(1000),
+	ParsedSessionQueueSize: config.ConfigQueueSize(10),
+	ParsedAddr:             "127.0.0.1:0",
+	ParsedKeyPEMFile:       "",
+	ParsedCertPEMFile:      "",
+	keyPEMBlock:            helpers.TestKeyPEMBlock,
+	certPEMBlock:           helpers.TestCertPEMBlock,
+}
+
+func (s *runnerSuite) TestDevicesRunner(c *C) {
+	buf := &bytes.Buffer{}
+	prevBootLogger := BootLogger
+	BootLogger = logger.NewSimpleLogger(buf, "debug")
+	defer func() {
+		BootLogger = prevBootLogger
+	}()
+	runner := DevicesRunner(func(conn net.Conn) error { return nil }, BootLogger, &testDevicesParsedConfig)
+	c.Assert(s.lst, Not(IsNil))
+	s.lst.Close()
+	c.Check(s.kind, Equals, "devices")
+	c.Check(runner, PanicMatches, "accepting device connections:.*closed.*")
 }

=== modified file 'server/dev/server.go'
--- server/dev/server.go	2014-01-17 17:21:35 +0000
+++ server/dev/server.go	2014-01-22 09:51:22 +0000
@@ -18,70 +18,48 @@
 package main
 
 import (
+	"launchpad.net/ubuntu-push/config"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/server/api"
 	"launchpad.net/ubuntu-push/server/broker"
-	"launchpad.net/ubuntu-push/server/listener"
 	"launchpad.net/ubuntu-push/server/session"
 	"launchpad.net/ubuntu-push/server/store"
 	"net"
 	"os"
 	"path/filepath"
-	"syscall"
 )
 
+type configuration struct {
+	// device server configuration
+	DevicesParsedConfig
+	// api http server configuration
+	HTTPServeParsedConfig
+}
+
 func main() {
+	cfgFpaths := os.Args[1:]
+	cfg := &configuration{}
+	err := config.ReadFiles(cfg, cfgFpaths...)
+	if err != nil {
+		BootLogFatalf("reading config: %v", err)
+	}
+	err = cfg.DevicesParsedConfig.FinishLoad(filepath.Dir(cfgFpaths[len(cfgFpaths)-1]))
+	if err != nil {
+		BootLogFatalf("reading config: %v", err)
+	}
 	logger := logger.NewSimpleLogger(os.Stderr, "debug")
-	if len(os.Args) < 2 { // xxx use flag
-		logger.Fatalf("missing config file")
-	}
-	configFName := os.Args[1]
-	f, err := os.Open(configFName)
-	if err != nil {
-		logger.Fatalf("reading config: %v", err)
-	}
-	cfg := &configuration{}
-	err = cfg.read(f, filepath.Dir(configFName))
-	if err != nil {
-		logger.Fatalf("reading config: %v", err)
-	}
 	// setup a pending store and start the broker
 	sto := store.NewInMemoryPendingStore()
 	broker := broker.NewSimpleBroker(sto, cfg, logger)
 	broker.Start()
 	defer broker.Stop()
 	// serve the http api
-	httpLst, err := net.Listen("tcp", cfg.HTTPAddr())
-	if err != nil {
-		logger.Fatalf("start http listening: %v", err)
-	}
 	handler := api.MakeHandlersMux(sto, broker, logger)
 	handler = api.PanicTo500Handler(handler, logger)
-	logger.Infof("listening for http on %v", httpLst.Addr())
-	go func() {
-		err := RunHTTPServe(httpLst, handler, cfg)
-		if err != nil {
-			logger.Fatalf("accepting http connections: %v", err)
-		}
-	}()
+	go HTTPServeRunner(handler, &cfg.HTTPServeParsedConfig)()
 	// listen for device connections
-	logger.Debugf("PingInterval: %s, ExchangeTimeout %s", cfg.PingInterval(), cfg.ExchangeTimeout())
-	var rlim syscall.Rlimit
-	err = syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlim)
-	if err != nil {
-		logger.Fatalf("getrlimit failed: %v", err)
-	}
-	logger.Debugf("nofile soft: %d hard: %d", rlim.Cur, rlim.Max)
-	lst, err := listener.DeviceListen(cfg)
-	if err != nil {
-		logger.Fatalf("start device listening: %v", err)
-	}
-	logger.Infof("listening for devices on %v", lst.Addr())
-	err = lst.AcceptLoop(func(conn net.Conn) error {
+	DevicesRunner(func(conn net.Conn) error {
 		track := session.NewTracker(logger)
 		return session.Session(conn, broker, cfg, track)
-	}, logger)
-	if err != nil {
-		logger.Fatalf("accepting device connections: %v", err)
-	}
+	}, logger, &cfg.DevicesParsedConfig)()
 }