New sjRPC API. (ea45151e) · Commits · Mirror / cc-node

ccnode/host/init.py

+0 −4

Original line number	Diff line number	Diff line
		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

+0 −9

Original line number	Diff line number	Diff line
		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

+18 −24

Original line number	Diff line number	Diff line
		@@ -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