Merge lp:~pedronis/ubuntu-push/fixes-to-wily into lp:ubuntu-push

[Samuele Pedroni]

* address lp:1451510 aggressively finding gone notifications in Tags()
* truncate runtime.Stack result to size, otherwise we log \x00s or old stuff

bring in recent fixes, mainly addressing lp:1451510

[Samuele Pedroni (pedronis)]

review: Approve

[lp:~pedronis/ubuntu-push/fixes-to-wily]

150. By Samuele Pedroni on 2015-08-14

revert rules

=== modified file 'client/service/postal.go'
--- client/service/postal.go	2015-03-05 14:09:54 +0000
+++ client/service/postal.go	2015-08-14 14:03:06 +0000
@@ -53,7 +53,6 @@
 	Presenter
 	GetCh() chan *reply.MMActionReply
 	RemoveNotification(string, bool)
-	StartCleanupLoop()
 	Tags(*click.AppId) []string
 	Clear(*click.AppId, ...string) int
 }
@@ -187,7 +186,6 @@
 
 	go svc.consumeHelperResults(svc.HelperPool.Start())
 	go svc.handleActions(actionsCh, svc.messagingMenu.GetCh())
-	svc.messagingMenu.StartCleanupLoop()
 	return nil
 }
 

=== modified file 'messaging/cmessaging/cmessaging.go'
--- messaging/cmessaging/cmessaging.go	2014-08-07 10:20:35 +0000
+++ messaging/cmessaging/cmessaging.go	2015-08-14 14:03:06 +0000
@@ -44,7 +44,6 @@
 	Actions []string
 	App     *click.AppId
 	Tag     string
-	Gone    bool
 }
 
 func gchar(s string) *C.gchar {

=== modified file 'messaging/messaging.go'
--- messaging/messaging.go	2015-01-22 09:52:07 +0000
+++ messaging/messaging.go	2015-08-14 14:03:06 +0000
@@ -31,23 +31,19 @@
 	"launchpad.net/ubuntu-push/messaging/reply"
 )
 
-var cleanupLoopDuration = 5 * time.Minute
-
 type MessagingMenu struct {
-	Log               logger.Logger
-	Ch                chan *reply.MMActionReply
-	notifications     map[string]*cmessaging.Payload // keep a ref to the Payload used in the MMU callback
-	lock              sync.RWMutex
-	stopCleanupLoopCh chan bool
-	ticker            *time.Ticker
-	tickerCh          <-chan time.Time
+	Log             logger.Logger
+	Ch              chan *reply.MMActionReply
+	notifications   map[string]*cmessaging.Payload // keep a ref to the Payload used in the MMU callback
+	lock            sync.RWMutex
+	lastCleanupTime time.Time
 }
 
+type cleanUp func()
+
 // New returns a new MessagingMenu
 func New(log logger.Logger) *MessagingMenu {
-	ticker := time.NewTicker(cleanupLoopDuration)
-	stopCh := make(chan bool)
-	return &MessagingMenu{Log: log, Ch: make(chan *reply.MMActionReply), notifications: make(map[string]*cmessaging.Payload), ticker: ticker, tickerCh: ticker.C, stopCleanupLoopCh: stopCh}
+	return &MessagingMenu{Log: log, Ch: make(chan *reply.MMActionReply), notifications: make(map[string]*cmessaging.Payload)}
 }
 
 var cAddNotification = cmessaging.AddNotification
@@ -59,12 +55,23 @@
 	return mmu.Ch
 }
 
-func (mmu *MessagingMenu) addNotification(app *click.AppId, notificationId string, tag string, card *launch_helper.Card, actions []string) {
+func (mmu *MessagingMenu) addNotification(app *click.AppId, notificationId string, tag string, card *launch_helper.Card, actions []string, testingCleanUpFunction cleanUp) {
 	mmu.lock.Lock()
 	defer mmu.lock.Unlock()
 	payload := &cmessaging.Payload{Ch: mmu.Ch, Actions: actions, App: app, Tag: tag}
 	mmu.notifications[notificationId] = payload
 	cAddNotification(app.DesktopId(), notificationId, card, payload)
+
+	// Clean up our internal notifications store if it holds more than 20 messages (and apparently nobody ever calls Tags())
+	if len(mmu.notifications) > 20 && time.Since(mmu.lastCleanupTime).Minutes() > 10 {
+		mmu.lastCleanupTime = time.Now()
+		if testingCleanUpFunction == nil {
+			go mmu.cleanUpNotifications()
+		} else {
+			testingCleanUpFunction() // Has to implement the asynchronous part itself
+		}
+
+	}
 }
 
 func (mmu *MessagingMenu) RemoveNotification(notificationId string, fromUI bool) {
@@ -77,53 +84,28 @@
 	}
 }
 
-// cleanupNotifications remove notifications that were cleared from the messaging menu
 func (mmu *MessagingMenu) cleanUpNotifications() {
 	mmu.lock.Lock()
 	defer mmu.lock.Unlock()
+	mmu.doCleanUpNotifications()
+}
+
+// doCleanupNotifications removes notifications that were cleared from the messaging menu
+func (mmu *MessagingMenu) doCleanUpNotifications() {
 	for nid, payload := range mmu.notifications {
-		if payload.Gone {
-			// sweep
+		if !cNotificationExists(payload.App.DesktopId(), nid) {
 			delete(mmu.notifications, nid)
-			// don't check the mmu for this nid
-			continue
-		}
-		exists := cNotificationExists(payload.App.DesktopId(), nid)
-		if !exists {
-			// mark
-			payload.Gone = true
 		}
 	}
 }
 
-func (mmu *MessagingMenu) StartCleanupLoop() {
-	mmu.doStartCleanupLoop(mmu.cleanUpNotifications)
-}
-
-func (mmu *MessagingMenu) doStartCleanupLoop(cleanupFunc func()) {
-	go func() {
-		for {
-			select {
-			case <-mmu.tickerCh:
-				cleanupFunc()
-			case <-mmu.stopCleanupLoopCh:
-				mmu.ticker.Stop()
-				mmu.Log.Debugf("CleanupLoop stopped.")
-				return
-			}
-		}
-	}()
-}
-
-func (mmu *MessagingMenu) StopCleanupLoop() {
-	mmu.stopCleanupLoopCh <- true
-}
-
 func (mmu *MessagingMenu) Tags(app *click.AppId) []string {
 	orig := app.Original()
 	tags := []string(nil)
-	mmu.lock.RLock()
-	defer mmu.lock.RUnlock()
+	mmu.lock.Lock()
+	defer mmu.lock.Unlock()
+	mmu.lastCleanupTime = time.Now()
+	mmu.doCleanUpNotifications()
 	for _, payload := range mmu.notifications {
 		if payload.App.Original() == orig {
 			tags = append(tags, payload.Tag)
@@ -156,6 +138,7 @@
 	for _, nid := range nids {
 		mmu.RemoveNotification(nid, true)
 	}
+	mmu.cleanUpNotifications()
 
 	return len(nids)
 }
@@ -190,7 +173,7 @@
 
 	mmu.Log.Debugf("[%s] creating notification centre entry for %s (summary: %s)", nid, app.Base(), card.Summary)
 
-	mmu.addNotification(app, nid, notification.Tag, card, actions)
+	mmu.addNotification(app, nid, notification.Tag, card, actions, nil)
 
 	return true
 }

=== modified file 'messaging/messaging_test.go'
--- messaging/messaging_test.go	2014-11-25 18:33:24 +0000
+++ messaging/messaging_test.go	2015-08-14 14:03:06 +0000
@@ -18,6 +18,8 @@
 
 import (
 	"sort"
+	"strconv"
+	"sync"
 	"time"
 
 	. "launchpad.net/gocheck"
@@ -48,8 +50,6 @@
 	cRemoveNotification = func(a, n string) {
 		ms.log.Debugf("REMOVE: app: %s, not: %s", a, n)
 	}
-	// just in case
-	cNotificationExists = nil
 }
 
 func (ms *MessagingSuite) TearDownSuite(c *C) {
@@ -61,6 +61,8 @@
 func (ms *MessagingSuite) SetUpTest(c *C) {
 	ms.log = helpers.NewTestLogger(c, "debug")
 	ms.app = clickhelp.MustParseAppId("com.example.test_test_0")
+	// just in case
+	cNotificationExists = nil
 }
 
 func (ms *MessagingSuite) TestPresentPresents(c *C) {
@@ -135,11 +137,23 @@
 		return &launch_helper.Notification{Card: &card, Tag: s}
 	}
 
+	existsCount := 0
+	// patch cNotificationExists to return true
+	cNotificationExists = func(did string, nid string) bool {
+		existsCount++
+		return true
+	}
+
 	c.Check(mmu.Tags(ms.app), IsNil)
 	c.Assert(mmu.Present(ms.app, "notif1", f("one")), Equals, true)
 	ms.checkTags(c, mmu.Tags(ms.app), []string{"one"})
+	c.Check(existsCount, Equals, 1)
+	existsCount = 0
+
 	c.Assert(mmu.Present(ms.app, "notif2", f("")), Equals, true)
 	ms.checkTags(c, mmu.Tags(ms.app), []string{"one", ""})
+	c.Check(existsCount, Equals, 2)
+
 	// and an empty notification doesn't count
 	c.Assert(mmu.Present(ms.app, "notif3", &launch_helper.Notification{Tag: "X"}), Equals, false)
 	ms.checkTags(c, mmu.Tags(ms.app), []string{"one", ""})
@@ -172,6 +186,12 @@
 	c.Assert(f(app3, "notif6", "one", true), Equals, true)
 	c.Assert(f(app3, "notif7", "", true), Equals, true)
 
+	// patch cNotificationExists to return true in order to make sure that messages
+	// do not get deleted by the doCleanUpTags() call in the Tags() function
+	cNotificationExists = func(did string, nid string) bool {
+		return true
+	}
+
 	// that is:
 	//   app 1: "one", "two", "";
 	//   app 2: "one", "two";
@@ -223,7 +243,7 @@
 	mmu := New(ms.log)
 	card := launch_helper.Card{Summary: "ehlo", Persist: true, Actions: []string{"action-1"}}
 	actions := []string{"{\"app\":\"com.example.test_test_0\",\"act\":\"action-1\",\"nid\":\"notif-id\"}", "action-1"}
-	mmu.addNotification(ms.app, "notif-id", "a-tag", &card, actions)
+	mmu.addNotification(ms.app, "notif-id", "a-tag", &card, actions, nil)
 
 	// check it's there
 	payload, ok := mmu.notifications["notif-id"]
@@ -242,7 +262,7 @@
 	mmu := New(ms.log)
 	card := launch_helper.Card{Summary: "ehlo", Persist: true, Actions: []string{"action-1"}}
 	actions := []string{"{\"app\":\"com.example.test_test_0\",\"act\":\"action-1\",\"nid\":\"notif-id\"}", "action-1"}
-	mmu.addNotification(ms.app, "notif-id", "a-tag", &card, actions)
+	mmu.addNotification(ms.app, "notif-id", "a-tag", &card, actions, nil)
 
 	// check it's there
 	_, ok := mmu.notifications["notif-id"]
@@ -261,13 +281,13 @@
 	mmu := New(ms.log)
 	card := launch_helper.Card{Summary: "ehlo", Persist: true, Actions: []string{"action-1"}}
 	actions := []string{"{\"app\":\"com.example.test_test_0\",\"act\":\"action-1\",\"nid\":\"notif-id\"}", "action-1"}
-	mmu.addNotification(ms.app, "notif-id", "", &card, actions)
+	mmu.addNotification(ms.app, "notif-id", "", &card, actions, nil)
 
 	// check it's there
 	_, ok := mmu.notifications["notif-id"]
 	c.Check(ok, Equals, true)
 
-	// patch cnotificationexists to return true
+	// patch cNotificationExists to return true
 	cNotificationExists = func(did string, nid string) bool {
 		return true
 	}
@@ -276,62 +296,94 @@
 	// check it's still there
 	_, ok = mmu.notifications["notif-id"]
 	c.Check(ok, Equals, true)
-	// patch cnotificationexists to return false
+
+	// patch cNotificationExists to return false
 	cNotificationExists = func(did string, nid string) bool {
 		return false
 	}
-	// mark the notification
-	mmu.cleanUpNotifications()
-	// check it's gone
-	_, ok = mmu.notifications["notif-id"]
-	c.Check(ok, Equals, true)
-	// sweep the notification
+	// remove the notification
 	mmu.cleanUpNotifications()
 	// check it's gone
 	_, ok = mmu.notifications["notif-id"]
 	c.Check(ok, Equals, false)
 }
 
-func (ms *MessagingSuite) TestCleanupLoop(c *C) {
-	mmu := New(ms.log)
-	tickerCh := make(chan time.Time)
-	mmu.tickerCh = tickerCh
-	cleanupCh := make(chan bool)
-	cleanupFunc := func() {
-		cleanupCh <- true
-	}
-	// start the cleanup loop
-	mmu.doStartCleanupLoop(cleanupFunc)
-	// mark
-	tickerCh <- time.Now()
-	// check it was called
-	<-cleanupCh
-	// stop the loop and check that it's actually stopped.
-	mmu.StopCleanupLoop()
-	c.Check(ms.log.Captured(), Matches, "(?s).*DEBUG CleanupLoop stopped.*")
-}
-
-func (ms *MessagingSuite) TestStartCleanupLoop(c *C) {
-	mmu := New(ms.log)
-	tickerCh := make(chan time.Time)
-	mmu.tickerCh = tickerCh
-	card := launch_helper.Card{Summary: "ehlo", Persist: true, Actions: []string{"action-1"}}
-	actions := []string{"{\"app\":\"com.example.test_test_0\",\"act\":\"action-1\",\"nid\":\"notif-id\"}", "action-1"}
-	mmu.addNotification(ms.app, "notif-id", "", &card, actions)
-	// patch cnotificationexists to return true and signal when it's called
-	notifExistsCh := make(chan bool)
+func (ms *MessagingSuite) TestCleanupInAddNotification(c *C) {
+	mmu := New(ms.log)
+
+	var wg sync.WaitGroup
+
+	var cleanUpAsynchronously = func() {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			mmu.cleanUpNotifications()
+		}()
+	}
+
+	showNotification := func(number int) {
+		action := "action-" + strconv.Itoa(number)
+		notificationId := "notif-id-" + strconv.Itoa(number)
+		card := launch_helper.Card{Summary: "ehlo", Persist: true, Actions: []string{action}}
+		actions := []string{"{\"app\":\"com.example.test_test_0\",\"act\":\"" + action + "\",\"nid\":\"" + notificationId + "\"}", action}
+		mmu.addNotification(ms.app, notificationId, "", &card, actions, cleanUpAsynchronously)
+	}
+
+	// Add 20 notifications
+	for i := 0; i < 20; i++ {
+		showNotification(i)
+	}
+
+	// wait for the cleanup goroutine in addNotification to finish in case it gets called (which it shouldn't!)
+	wg.Wait()
+
+	// check that we have got 20 notifications
+	c.Check(mmu.notifications, HasLen, 20)
+
+	// patch cNotificationExists to return true
 	cNotificationExists = func(did string, nid string) bool {
-		notifExistsCh <- true
 		return true
 	}
-	// statr the cleanup loop
-	mmu.StartCleanupLoop()
-	// mark
-	tickerCh <- time.Now()
-	// check it's there, and marked
-	<-notifExistsCh
-	// stop the loop
-	mmu.StopCleanupLoop()
+
+	// adding another notification should not remove the current ones
+	showNotification(21)
+
+	// wait for the cleanup goroutine in addNotification to finish in case it gets called (which it shouldn't!)
+	wg.Wait()
+
+	// check we that have 21 notifications now
+	c.Check(mmu.notifications, HasLen, 21)
+
+	// patch cNotificationExists to return false for all but the next one we are going to add
+	cNotificationExists = func(did string, nid string) bool {
+		return nid == "notif-id-22"
+	}
+
+	// adding another notification should not remove the current ones as mmu.lastCleanupTime is too recent
+	showNotification(22)
+
+	// wait for the cleanup goroutine in addNotification to finish in case it gets called (which it shouldn't!)
+	wg.Wait()
+
+	// check we that have got 22 notifications now
+	c.Check(mmu.notifications, HasLen, 22)
+
+	// set back the lastCleanupTime to 11 minutes ago
+	mmu.lastCleanupTime = mmu.lastCleanupTime.Add(-11 * time.Minute)
+
+	// patch cNotificationExists to return false for all but the next one we are going to add
+	cNotificationExists = func(did string, nid string) bool {
+		return nid == "notif-id-23"
+	}
+
+	// adding another notification should remove all previous ones now
+	showNotification(23)
+
+	// wait for the cleanup goroutine in addNotification to finish
+	wg.Wait()
+
+	// check that all notifications except the last one have been removed
+	c.Check(mmu.notifications, HasLen, 1)
 }
 
 func (ms *MessagingSuite) TestGetCh(c *C) {

=== modified file 'server/acceptance/acceptanceclient.go'
--- server/acceptance/acceptanceclient.go	2015-04-16 12:16:51 +0000
+++ server/acceptance/acceptanceclient.go	2015-08-14 14:03:06 +0000
@@ -49,6 +49,8 @@
 	cookie          string
 	cookieLock      sync.RWMutex
 	ReportSetParams bool
+	DontClose       bool
+	SlowStart       time.Duration
 	// connection
 	Connection net.Conn
 }
@@ -101,7 +103,10 @@
 // Run the session with the server, emits a stream of events.
 func (sess *ClientSession) Run(events chan<- string) error {
 	conn := sess.Connection
-	defer conn.Close()
+	if !sess.DontClose {
+		defer conn.Close()
+	}
+	time.Sleep(sess.SlowStart)
 	conn.SetDeadline(time.Now().Add(sess.ExchangeTimeout))
 	_, err := conn.Write(wireVersionBytes)
 	if err != nil {

=== modified file 'server/acceptance/cmd/acceptanceclient.go'
--- server/acceptance/cmd/acceptanceclient.go	2014-08-20 19:48:59 +0000
+++ server/acceptance/cmd/acceptanceclient.go	2015-08-14 14:03:06 +0000
@@ -36,7 +36,7 @@
 	kit.Defaults["auth_helper"] = ""
 	kit.Defaults["wait_for"] = ""
 	cfg := &configuration{}
-	kit.CliLoop(cfg, &cfg.Configuration, func(session *acceptance.ClientSession, cfgDir string) {
+	kit.CliLoop(cfg, &cfg.Configuration, func(session *acceptance.ClientSession, apiCli *kit.APIClient, cfgDir string) {
 		log.Printf("with: %#v", session)
 	}, func(url string) string {
 		if cfg.AuthHelper == "" {

=== modified file 'server/acceptance/kit/api.go'
--- server/acceptance/kit/api.go	2015-04-16 12:16:51 +0000
+++ server/acceptance/kit/api.go	2015-08-14 14:03:06 +0000
@@ -23,8 +23,10 @@
 	"crypto/tls"
 	"encoding/json"
 	"errors"
+	"io"
 	"io/ioutil"
 	"net/http"
+	"net/url"
 )
 
 // APIClient helps making api requests.
@@ -56,6 +58,20 @@
 
 var ErrNOk = errors.New("not ok")
 
+func readBody(respBody io.ReadCloser) (map[string]interface{}, error) {
+	defer respBody.Close()
+	body, err := ioutil.ReadAll(respBody)
+	if err != nil {
+		return nil, err
+	}
+	var res map[string]interface{}
+	err = json.Unmarshal(body, &res)
+	if err != nil {
+		return nil, &APIError{err.Error(), body}
+	}
+	return res, nil
+}
+
 // Post a API request.
 func (api *APIClient) PostRequest(path string, message interface{}) (map[string]interface{}, error) {
 	packedMessage, err := json.Marshal(message)
@@ -77,18 +93,36 @@
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
+	res, err := readBody(resp.Body)
 	if err != nil {
 		return nil, err
 	}
-	var res map[string]interface{}
-	err = json.Unmarshal(body, &res)
-	if err != nil {
-		return nil, &APIError{err.Error(), body}
-	}
+
 	if ok, _ := res["ok"].(bool); !ok {
 		return res, ErrNOk
 	}
 	return res, nil
 }
+
+// Get resource from API endpoint.
+func (api *APIClient) GetRequest(path string, params map[string]string) (map[string]interface{}, error) {
+	apiURL := api.ServerAPIURL + path
+	if len(params) != 0 {
+		vals := url.Values{}
+		for k, v := range params {
+			vals.Set(k, v)
+		}
+		apiURL += "?" + vals.Encode()
+	}
+	request, _ := http.NewRequest("GET", apiURL, nil)
+
+	resp, err := api.httpClient.Do(request)
+	if err != nil {
+		return nil, err
+	}
+	res, err := readBody(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	return res, nil
+}

=== modified file 'server/acceptance/kit/cliloop.go'
--- server/acceptance/kit/cliloop.go	2015-04-15 15:35:12 +0000
+++ server/acceptance/kit/cliloop.go	2015-08-14 14:03:06 +0000
@@ -17,6 +17,7 @@
 package kit
 
 import (
+	"crypto/tls"
 	"flag"
 	"fmt"
 	"log"
@@ -26,6 +27,8 @@
 	"strings"
 	"time"
 
+	"launchpad.net/ubuntu-push/external/murmur3"
+
 	"launchpad.net/ubuntu-push/config"
 	"launchpad.net/ubuntu-push/server/acceptance"
 )
@@ -34,11 +37,15 @@
 	// session configuration
 	ExchangeTimeout config.ConfigTimeDuration `json:"exchange_timeout"`
 	// server connection config
-	Target      string                `json:"target"`
+	Target      string                `json:"target" help:"production|staging - picks defaults"`
 	Addr        config.ConfigHostPort `json:"addr"`
+	Vnode       string                `json:"vnode" help:"vnode postfix to make up a targeting device-id"`
 	CertPEMFile string                `json:"cert_pem_file"`
 	Insecure    bool                  `json:"insecure" help:"disable checking of server certificate and hostname"`
 	Domain      string                `json:"domain" help:"domain for tls connect"`
+	// api config
+	APIURL         string `json:"api" help:"api url"`
+	APICertPEMFile string `json:"api_cert_pem_file"`
 	// run timeout
 	RunTimeout config.ConfigTimeDuration `json:"run_timeout"`
 	// flags
@@ -66,22 +73,25 @@
 var (
 	Name     = "acceptanceclient"
 	Defaults = map[string]interface{}{
-		"target":           "",
-		"addr":             ":0",
-		"exchange_timeout": "5s",
-		"cert_pem_file":    "",
-		"insecure":         false,
-		"domain":           "",
-		"run_timeout":      "0s",
-		"reportPings":      true,
-		"model":            "?",
-		"imageChannel":     "?",
-		"buildNumber":      -1,
+		"target":            "",
+		"addr":              ":0",
+		"vnode":             "",
+		"exchange_timeout":  "5s",
+		"cert_pem_file":     "",
+		"insecure":          false,
+		"domain":            "",
+		"run_timeout":       "0s",
+		"reportPings":       true,
+		"model":             "?",
+		"imageChannel":      "?",
+		"buildNumber":       -1,
+		"api":               "",
+		"api_cert_pem_file": "",
 	}
 )
 
 // CliLoop parses command line arguments and runs a client loop.
-func CliLoop(totalCfg interface{}, cfg *Configuration, onSetup func(sess *acceptance.ClientSession, cfgDir string), auth func(string) string, waitFor func() string, onConnect func()) {
+func CliLoop(totalCfg interface{}, cfg *Configuration, onSetup func(sess *acceptance.ClientSession, apiCli *APIClient, cfgDir string), auth func(string) string, waitFor func() string, onConnect func()) {
 	flag.Usage = func() {
 		fmt.Fprintf(os.Stderr, "Usage: %s [options] <device id>\n", Name)
 		flag.PrintDefaults()
@@ -95,31 +105,71 @@
 	if err != nil {
 		log.Fatalf("reading config: %v", err)
 	}
-	narg := flag.NArg()
-	switch {
-	case narg < 1:
-		missingArg("device-id")
+	deviceId := ""
+	if cfg.Vnode != "" {
+		if cfg.Addr == ":0" {
+			log.Fatalf("-vnode needs -addr specified")
+		}
+		deviceId = cfg.Addr.HostPort() + "|" + cfg.Vnode
+		log.Printf("using device-id: %q", deviceId)
+	} else {
+		narg := flag.NArg()
+		switch {
+		case narg < 1:
+			missingArg("device-id")
+		}
+		deviceId = flag.Arg(0)
+	}
+	cfgDir := filepath.Dir(flag.Lookup("cfg@").Value.String())
+	// setup api
+	apiCli := &APIClient{}
+	var apiTLSConfig *tls.Config
+	if cfg.APICertPEMFile != "" || cfg.Insecure {
+		var err error
+		apiTLSConfig, err = MakeTLSConfig("", cfg.Insecure,
+			cfg.APICertPEMFile, cfgDir)
+		if err != nil {
+			log.Fatalf("api tls config: %v", err)
+		}
+	}
+	apiCli.SetupClient(apiTLSConfig, true, 1)
+	if cfg.APIURL == "" {
+		apiCli.ServerAPIURL = cfg.PickByTarget("api",
+			"https://push.ubuntu.com",
+			"https://push.staging.ubuntu.com")
+	} else {
+		apiCli.ServerAPIURL = cfg.APIURL
 	}
 	addr := ""
+	domain := ""
 	if cfg.Addr == ":0" {
-		addr = cfg.PickByTarget("addr", "push-delivery.ubuntu.com:443",
-			"push-delivery.staging.ubuntu.com:443")
+		hash := murmur3.Sum64([]byte(deviceId))
+		hosts, err := apiCli.GetRequest("/delivery-hosts",
+			map[string]string{
+				"h": fmt.Sprintf("%x", hash),
+			})
+		if err != nil {
+			log.Fatalf("querying hosts: %v", err)
+		}
+		addr = hosts["hosts"].([]interface{})[0].(string)
+		domain = hosts["domain"].(string)
+		log.Printf("using: %s %s", addr, domain)
 	} else {
 		addr = cfg.Addr.HostPort()
+		domain = cfg.Domain
 	}
 	session := &acceptance.ClientSession{
 		ExchangeTimeout: cfg.ExchangeTimeout.TimeDuration(),
 		ServerAddr:      addr,
-		DeviceId:        flag.Arg(0),
+		DeviceId:        deviceId,
 		// flags
 		Model:        cfg.DeviceModel,
 		ImageChannel: cfg.ImageChannel,
 		BuildNumber:  cfg.BuildNumber,
 		ReportPings:  cfg.ReportPings,
 	}
-	cfgDir := filepath.Dir(flag.Lookup("cfg@").Value.String())
-	onSetup(session, cfgDir)
-	session.TLSConfig, err = MakeTLSConfig(cfg.Domain, cfg.Insecure, cfg.CertPEMFile, cfgDir)
+	onSetup(session, apiCli, cfgDir)
+	session.TLSConfig, err = MakeTLSConfig(domain, cfg.Insecure, cfg.CertPEMFile, cfgDir)
 	if err != nil {
 		log.Fatalf("tls config: %v", err)
 	}

=== modified file 'ubuntu-push-client.go'
--- ubuntu-push-client.go	2015-01-21 21:31:39 +0000
+++ ubuntu-push-client.go	2015-08-14 14:03:06 +0000
@@ -35,8 +35,8 @@
 		buf := make([]byte, 1<<20)
 		for {
 			<-sigs
-			runtime.Stack(buf, true)
-			log.Printf("=== received SIGQUIT ===\n*** goroutine dump...\n%s\n*** end\n", buf)
+			sz := runtime.Stack(buf, true)
+			log.Printf("=== received SIGQUIT ===\n*** goroutine dump...\n%s\n*** end", buf[:sz])
 		}
 	}()
 }