state/api: Machiner API facade

state/apiserver/apiserver.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package apiserver
 
 import (
         "code.google.com/p/go.net/websocket"
         "crypto/tls"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/rpc"
         "launchpad.net/juju-core/rpc/jsoncodec"
         "launchpad.net/juju-core/state"
         "launchpad.net/tomb"
         "net"
         "net/http"
         "sync"
 )
 
 // Server holds the server side of the API.
 type Server struct {
         tomb  tomb.Tomb
         wg    sync.WaitGroup
         state *state.State
         addr  net.Addr
+        root  *srvRoot
 }
 
 // Serve serves the given state by accepting requests on the given
 // listener, using the given certificate and key (in PEM format) for
 // authentication.
 func NewServer(s *state.State, addr string, cert, key []byte) (*Server, error) {
         lis, err := net.Listen("tcp", addr)
         if err != nil {
                 return nil, err
         }
         log.Infof("state/api: listening on %q", addr)
         tlsCert, err := tls.X509KeyPair(cert, key)
         if err != nil {
                 return nil, err
         }
         srv := &Server{
                 state: s,
                 addr:  lis.Addr(),
         }
         // TODO(rog) check that *srvRoot is a valid type for using
         // as an RPC server.
         lis = tls.NewListener(lis, &tls.Config{
                 Certificates: []tls.Certificate{tlsCert},
         })
+        srv.root = newStateServer(srv)
         go srv.run(lis)
         return srv, nil
 }
 
 // Dead returns a channel that signals when the server has exited.
 func (srv *Server) Dead() <-chan struct{} {
         return srv.tomb.Dead()
 }
 
 // Stop stops the server and returns when all running requests
@@ skipping 30 matching lines @@
         http.Serve(lis, handler)
 }
 
 // Addr returns the address that the server is listening on.
 func (srv *Server) Addr() string {
         return srv.addr.String()
 }
 
 func (srv *Server) serveConn(wsConn *websocket.Conn) error {
         conn := rpc.NewConn(jsoncodec.NewWebsocket(wsConn))
-        if err := conn.Serve(newStateServer(srv), serverError); err != nil {
+        if err := conn.Serve(srv.root, serverError); err != nil {

[fwereade, 2013/06/04 08:37:29]

Not clear on the impact of this change, but it smells a bit. Isn't
connection-specific auth accessed through root? If that's so, surely we can't
share it?

[dimitern, 2013/06/04 11:06:18]

Good catch! Reverted and changed as agreed - machiner gets a *state.State and
Authorizer interface, so this is no longer needed.

                 return err
         }
         conn.Start()
         select {
         case <-conn.Dead():
         case <-srv.tomb.Dying():
         }
         return conn.Close()
 }
 
 var logRequests = true