def __init__(self, name=None):
if name is None:
name = "pickler"
Marshaller.__init__(self, name)
self.key = ''
return
def __init__(self, name=None):
if name is None:
name = "pickler"
Marshaller.__init__(self, name)
self.key = ''
return
def __init__(self, client, uri, *args, **kw):
#logger.debug(self.__class__.__mro__)
super(Shadow, self).__init__(parent = None, manager = None, *args, **kw)
#logger.debug("Creating shadow for %s" % (uri, ))
self.__marshaller = Marshaller(client)
#self._proxy = PTMServerProxy(uri, allow_none = True)
self.__uri = uri
class Shadow(AbstractResourceAdapter):
def __init__(self, client, uri, *args, **kw):
#logger.debug(self.__class__.__mro__)
super(Shadow, self).__init__(parent = None, manager = None, *args, **kw)
#logger.debug("Creating shadow for %s" % (uri, ))
self.__marshaller = Marshaller(client)
#self._proxy = PTMServerProxy(uri, allow_none = True)
self.__uri = uri
def get_uri(self):
return self.__uri
uri = property(get_uri)
@property
def _proxy(self):
return PTMServerProxy(self.uri, allow_none = True)
def _mangle_id(self, id):
if Identifier(id) == Identifier("/"):
return None
if id is not None:
return unicode(Identifier(id, need_full = True))
return None
def _mangle_config(self, config):
if config is None:
return {}
if not isinstance(config, dict):
raise InternalTypeError("Expecting dict, not %s" % (config, ))
return self.__marshaller.pack_dict(config)
def add_resource(self, parent_id, name, typename, config, owner = None):
identifier = self._proxy.add_resource(self._mangle_id(parent_id), name and unicode(name) or None, typename and unicode(typename) or None,
self._mangle_config(config), owner and self.__marshaller.pack_value(owner) or None)
return self.__marshaller.make_proxy(identifier)
def get_resource(self, identifier):
return self.__marshaller.make_proxy(self._proxy.get_resource(unicode(self.__marshaller.pack_identifier(identifier))))
def have_resource(self, identifier):
return bool(self._proxy.have_resource(unicode(self.__marshaller.pack_identifier(identifier))))
def list_resources(self, parent_id, type = None):
return [ self.__marshaller.make_proxy(i) for i in self._proxy.list_resources(self._mangle_id(parent_id), type and type or None) ]
def get_configuration(self, identifier):
return self.__marshaller.unpack_dict(self._proxy.get_configuration(unicode(Identifier(identifier, need_full =True))))
def set_configuration(self, identifier, config):
self._proxy.set_configuration(self.__marshaller.pack_identifier(identifier), self.__marshaller.pack_dict(config))
def get_attribute(self, identifier, name):
return self.__marshaller.unpack_value(self._proxy.get_attribute(self.__marshaller.pack_identifier(identifier), unicode(name)))
def set_attribute(self, identifier, name, value):
self._proxy.set_attribute(self.__marshaller.pack_identifier(identifier), unicode(name), self.__marshaller.pack_value(value))
def delete_resource(self, identifier):
self._proxy.delete_resource(self.__marshaller.pack_identifier(identifier))
def execute_method(self, identifier, name, *args, **kw):
print "############################### id %s name %s args %s kw %s "%(identifier, name, args, kw,)
return self.__marshaller.unpack_value(self._proxy.execute_method(self.__marshaller.pack_identifier(identifier), unicode(name), self.__marshaller.pack_list(args), self.__marshaller.pack_dict(kw)))
def notify(self, condition, owner, reference):
if not owner:
raise InternalIllegalArgumentError(owner)
owner = unicode(Identifier(owner, need_abs = True))
reference = self.__marshaller.pack_identifier(reference)
self._proxy.notify(condition, owner, reference)
def __str__(self):
return "RA at %s" % (self.uri, )
def __unicode__(self):
return unicode(self.__str__())
def __eq__(self, o):
try:
return self.uri == o.uri
except AttributeError:
return False
def _configure(self):
Marshaller._configure(self)
self.key = self.inventory.key
return
def _configure(self):
Marshaller._configure(self)
self.key = self.inventory.key
return
def __init__(self, manager, *args, **kw): super(MethodDispatcher, self).__init__(*args, **kw) self._manager = manager self._marshaller = Marshaller(manager)
class MethodDispatcher(object):
def __init__(self, manager, *args, **kw):
super(MethodDispatcher, self).__init__(*args, **kw)
self._manager = manager
self._marshaller = Marshaller(manager)
def add_resource(self, parent, name, typename, config, owner):
owner = self._marshaller.unpack_owner(owner)
config = self._marshaller.unpack_dict(config)
r = self._manager.do_add_resource(parent, name, typename, config, owner)
return self._marshaller.pack_identifier(r)
def get_resource(self, identifier):
identifier = Identifier(identifier, need_full = True)
return self._marshaller.pack_identifier(self._manager.do_get_resource(identifier))
def list_resources(self, parent, typename):
typename = typename and unicode(typename) or None
parent = (parent and parent != "/") and Identifier(parent, need_full = True) or None
return [ self._marshaller.pack_identifier(i) for i in self._manager.do_list_resources(parent, typename) ]
def have_resource(self, identifier):
identifier = self._marshaller.unpack_identifier(identifier)
return bool(self._manager.do_have_resource(identifier))
def get_configuration(self, identifier):
identifier = self._marshaller.unpack_identifier(identifier)
config = self._manager.do_get_configuration(identifier)
logger.debug("Got config: %s" % (config, ))
config = self._marshaller.pack_dict(config.copy())
logger.debug("Returnin packed config: %s" % (config, ))
return config
def set_configuration(self, identifier, config):
identifier = self._marshaller.unpack_identifier(identifier)
self._manager.do_set_configuration(identifier, self._marshaller.unpack_dict(config))
def get_attribute(self, identifier, name):
identifier = self._marshaller.unpack_identifier(identifier)
return self._marshaller.pack_value(self._manager.do_get_attribute(identifier, name))
def set_attribute(self, identifier, name, value):
identifier = self._marshaller.unpack_identifier(identifier)
self._manager.do_set_attribute(identifier, name, self._marshaller.unpack_value(value))
def delete_resource(self, identifier):
identifier = self._marshaller.unpack_identifier(identifier)
self._manager.do_delete_resource(identifier)
def execute_method(self, identifier, name, args, kw):
identifier = self._marshaller.unpack_identifier(identifier)
self._manager.do_execute_method(identifier, name, self._marshaller.unpack_list(args), self._marshaller.unpack_dict(kw))
def notify(self, condition, owner, ref):
self._manager.do_notify(condition, owner, ref)
