state/api: Client connection health monitoring

state/api/apiclient.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package api
 
 import (
         "code.google.com/p/go.net/websocket"
         "crypto/tls"
         "crypto/x509"
         "launchpad.net/juju-core/cert"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/rpc"
         "launchpad.net/juju-core/rpc/jsoncodec"
         "launchpad.net/juju-core/utils"
         "time"
 )
 
-// PingFrequency defines how often the internal connection health
-// check will run.
-const PingFrequency = 5 * time.Second

[fwereade, 2013/05/28 07:11:21]

PingPeriod please.

[dimitern, 2013/05/28 07:22:56]

Done.

+// PingPeriod defines how often the internal connection health check
+// will run. It's a variable so it can be changed in tests.
+var PingPeriod = 5 * time.Second
 
 type State struct {
         client *rpc.Conn
         conn   *websocket.Conn
 
-        // closed is a channel that gets closed when the connection is
+        // broken is a channel that gets closed when the connection is
         // broken.
-        closed chan struct{}
+        broken chan struct{}
 }
 
 // Info encapsulates information about a server holding juju state and
 // can be used to make a connection to it.
 type Info struct {
         // Addrs holds the addresses of the state servers.
         Addrs []string
 
         // CACert holds the CA certificate that will be used
         // to validate the state server's certificate, in PEM format.
@@ skipping 51 matching lines @@
         st := &State{
                 client: client,
                 conn:   conn,
         }
         if info.Tag != "" || info.Password != "" {
                 if err := st.Login(info.Tag, info.Password); err != nil {
                         conn.Close()
                         return nil, err
                 }
         }
-        st.closed = make(chan struct{})
-        go st.healthMonitor()
+        st.broken = make(chan struct{})
+        go st.heartbeatMonitor()
         return st, nil
 }
 
-func (s *State) healthMonitor() {
+func (s *State) heartbeatMonitor() {
         ping := func() error {
                 return s.call("State", "", "Ping", nil, nil)
         }
         for {
                 if err := ping(); err != nil {
-                        close(s.closed)
+                        close(s.broken)
                         return
                 }
-                time.Sleep(PingFrequency)
+                time.Sleep(PingPeriod)
         }
 }
 
 func (s *State) call(objType, id, request string, params, response interface{}) error {
         err := s.client.Call(objType, id, request, params, response)
         return clientError(err)
 }
 
 func (s *State) Close() error {
         return s.client.Close()
 }
 
-// SetDeadlines set the connection's network read and write deadlines.

[fwereade, 2013/05/28 07:11:21]

I'd prefer something like Broken rather than Closed... maybe that's a bikeshed,
but we can in theory be broken without actually being closed... right?

[dimitern, 2013/05/28 07:22:56]

Done.

-func (s *State) Closed() <-chan struct{} {
-        return s.closed
+// Broken returns a channel that's closed when the connection is broken.
+func (s *State) Broken() <-chan struct{} {
+        return s.broken
 }
 
 // RPCClient returns the RPC client for the state, so that testing
 // functions can tickle parts of the API that the conventional entry
 // points don't reach. This is exported for testing purposes only.
 func (s *State) RPCClient() *rpc.Conn {
         return s.client
 }