New sjRPC API.

ccnode/host/__init__.py

 import logging
 from subprocess import Popen, PIPE, STDOUT
 
-from sjrpc.utils import pure
-
 from ccnode.node import DefaultHandler
 from ccnode.tags import tag_inspector
 from ccnode.host import tags
@@ -19,7 +17,6 @@ class Handler(DefaultHandler):
         for t in tag_inspector(tags):
             self.tags[t.name] = t
 
-    @pure
     def execute_command(self, command):
         """Execute an arbitrary shell command on the host.
 
@@ -29,7 +26,6 @@ class Handler(DefaultHandler):
         return Popen(command, shell=True, bufsize=-1, stdin=PIPE, stdout=PIPE,
                      stderr=STDOUT).communicate()[0] or None
 
-    @pure
     def node_shutdown(self, reboot=True, gracefull=True):
         """Halt/Reboot the node.
 

ccnode/hypervisor/__init__.py

 import logging
 
 import libvirt
-from sjrpc.utils import pure
 
 from ccnode.host import Handler as HostHandler
 from ccnode.tags import tag_inspector, get_tags
@@ -39,7 +38,6 @@ class Handler(HostHandler):
             logger.debug(u'Registered domain %s' % name)
             proxy.register(name, 'vm')
 
-    @pure
     def sub_tags(self, sub_id, tags=None, noresolve_tags=None):
         """Get subtags."""
         global hypervisor
@@ -52,31 +50,24 @@ class Handler(HostHandler):
 
         return get_tags(domain, tags, noresolve_tags)
 
-    @pure
     def vm_define(self, name):
         pass
 
-    @pure
     def vm_undefine(self, name):
         pass
 
-    @pure
     def vm_export(self, name, format='xml'):
         pass
 
-    @pure
     def vm_stop(self, vm_names=None, force=False):
         pass
 
-    @pure
     def vm_start(self, vm_names=None):
         pass
 
-    @pure
     def vm_suspend(self, vm_names=None):
         pass
 
-    @pure
     def vm_resume(self, vm_names=None):
         pass
 

ccnode/node.py

@@ -2,8 +2,8 @@ import time
 import logging
 from threading import Thread, Lock
 
-from sjrpc.client import SimpleRpcClient
-from sjrpc.utils import ConnectionProxy, RpcHandler, pure
+from sjrpc.core import RpcConnection
+from sjrpc.utils import ConnectionProxy, RpcHandler
 
 from ccnode import __version__
 from ccnode.tags import Tag, get_tags
@@ -27,7 +27,6 @@ class DefaultHandler(RpcHandler):
 
         self.tags = dict((t.name, t) for t in DEFAULT_TAGS)
 
-    @pure
     def get_tags(self, tags=None, noresolve_tags=None):
         """Method used from the ``cc-server`` to get tags.
 
@@ -59,26 +58,24 @@ class Node(Thread):
 
         #: ``sjRpc`` proxy
         self.proxy = None
-        #: ``sjRpc`` connection manager
-        self.manager = None
+        #: ``sjRpc`` connection
+        self.connection = None
         #: role returned by cc-server (set to None unless the authentication
         #: has succeed)
         self.role = None
 
-        self._manager_lock = Lock()
+        self._connection_lock = Lock()
 
     def init_rpc(self):
-        """Init a new connection to ``cc-server``, create a ``sjRpc`` manager
-        and proxy.
+        """Init a new connection to ``cc-server``, create a ``sjRpc`` proxy.
 
         """
-        self.manager = SimpleRpcClient.from_addr(
+        self.connection = RpcConnection.from_addr_ssl(
             addr=self.server_host,
             port=self.server_port,
-            enable_ssl=True,
-            default_handler=DefaultHandler(),
+            handler=DefaultHandler(),
         )
-        self.proxy = ConnectionProxy(self.manager)
+        self.proxy = ConnectionProxy(self.connection)
 
     def authentify(self):
         """Try to authenticate to the server. If successfull, import and then
@@ -97,15 +94,12 @@ class Node(Thread):
         if role == u'host':
             logger.debug(u'Role host affected.')
             from ccnode.host import Handler as HostHandler
-            # FIXME bad API
-            self.manager._connection.set_handler(HostHandler())
+            self.connection.rpc.set_handler(HostHandler())
             self.role = u'host'
         elif role == u'hv':
             logger.debug(u'Role hypervisor affected.')
             from ccnode.hypervisor import Handler as HypervisorHandler
-            # FIXME bad API
-            self.manager._connection.set_handler(HypervisorHandler(
-                proxy=self.proxy))
+            self.connection.rpc.set_handler(HypervisorHandler(proxy=self.proxy))
             self.role = u'hv'
         else:
             logger.debug(u'Wrong role returned: %s', role)
@@ -116,9 +110,9 @@ class Node(Thread):
 
     def rpc(self):
         """Runs ``sjRpc`` main loop. Catches exceptions. :func:`shutdown` the
-        manager before returning."""
+        connection before returning."""
         try:
-            self.manager.run()
+            self.connection.run()
         except Exception:
             logger.exception(u'Unknown exception:')
         finally:
@@ -156,9 +150,9 @@ class Node(Thread):
             self.role = None
 
     def shutdown(self):
-        """Shutdown the ``sjRpc`` manager and reset object state."""
-        with self._manager_lock:
-            if self.manager is not None:
-                self.manager.shutdown()
-                self.manager = None
+        """Shutdown the ``sjRpc`` connection and reset object state."""
+        with self._connection_lock:
+            if self.connection is not None:
+                self.connection.shutdown()
+                self.connection = None
                 self.role = None