# XML parser module
from xml.etree.ElementTree import XMLParser
-# For debug only
-import os
###############################################################################
-VERSION = "0.2.1"
+VERSION = "0.3.0"
OPENDOOR = False
CREDENTIALS = {}
WHITELIST = []
'''
return dbus error message
'''
- self.request.errback(error.get_dbus_message())
+ self.request.errback(Exception(error.get_dbus_message()))
self.pending = False
################################################################################
class exec_code:
- def __init__(self) :
+ def __init__(self, globalCtx, localCtx) :
self.exec_string = ""
self.exec_code = None
self.exec_code_valid = 1
self.indent_level = 0
self.indent_increment = 1
self.line = 0
-
- # __str__ : Return a string representation of the object, for
- # nice printing.
- def __str__(self) :
- return self.exec_string
-
- def p(self) :
- print str(self)
+ self.localCtx = localCtx
+ self.globalCtx = globalCtx
+
def append_stmt(self, stmt) :
self.exec_code_valid = 0
self.line += 1
- if (stmt != "\n"):
- for x in range(0,self.indent_level):
- self.exec_string = self.exec_string + ' '
- self.exec_string = self.exec_string + stmt + "\t\t# l:" + str(self.line) + '\n'
- else:
- if (stmt == "\n"):
- self.exec_string = self.exec_string + "# l:" + str(self.line) + '\n'
- else:
- self.exec_string = self.exec_string + stmt + "\t\t# l:" + str(self.line) + '\n'
+ for x in range(0,self.indent_level):
+ self.exec_string = self.exec_string + ' '
+ self.exec_string = self.exec_string + stmt + '\n'
def indent(self) :
self.indent_level = self.indent_level + self.indent_increment
def compile(self) :
if not self.exec_code_valid :
self.exec_code = compile(self.exec_string, "<string>", "exec")
- self.exec_code_valid = 1
+ self.exec_code_valid = True
def execute(self) :
if not self.exec_code_valid :
self.compile()
- exec self.exec_code
+ exec(self.exec_code, self.globalCtx, self.localCtx)
# Set signature (in/out & name) for method
if (tag == 'arg'):
if (self.current == 'method'):
+ if (attrib.has_key('direction') == False):
+ attrib['direction'] = "in"
self.dynDBusClass.add_signature(attrib['name'],
attrib['direction'],
attrib['type'])
def __init__(self, className, globalCtx, localCtx):
self.className = className
self.xmlCB = XmlCb_Parser(self)
- self.localCtx = localCtx
- self.globalCtx = globalCtx
self.signature = {}
- self.class_code = exec_code()
+ self.class_code = exec_code(globalCtx, localCtx)
self.class_code.indent_increment = 4
self.class_code.append_stmt("import dbus")
self.class_code.append_stmt("\n")
- self.class_code.append_stmt("\n")
self.class_code.append_stmt("class " + self.className + "(dbus.service.Object):")
self.class_code.indent()
self.add_stmt("self.bus = bus")
self.add_stmt("self.objName = objName")
self.add_stmt("self.callback = callback")
- self.add_stmt("dbus.service.Object.__init__(self, conn=bus, object_path=objName, bus_name=busName)")
+ self.add_stmt("dbus.service.Object.__init__(self, conn=bus, bus_name=busName)")
+ self.end_method()
+
+ ## Create 'add_to_connection' method
+ self.def_method("add_to_connection")
+ self.add_method("connection=None, path=None")
+ self.add_stmt("dbus.service.Object.add_to_connection(self, connection=self.bus, path=self.objName)")
+ self.end_method()
+
+ ## Create 'remove_from_connection' method
+ self.def_method("remove_from_connection")
+ self.add_method("connection=None, path=None")
+ self.add_stmt("dbus.service.Object.remove_from_connection(self, connection=None, path=self.objName)")
self.end_method()
def createDBusServiceFromXML(self, xml):
def end_method(self):
self.class_code.append_stmt("\n")
- self.class_code.append_stmt("\n")
self.class_code.dedent()
def add_dbus_method(self):
def add_body_method(self):
if (self.methodToAdd != None):
- self.class_code.append_stmt("print 'In " + self.methodToAdd + "()'")
if (self.args_str != str()):
self.class_code.append_stmt("self.callback('" + self.methodToAdd + "', dbus_async_cb, dbus_async_err_cb, %s)" % self.args_str)
else:
self.class_code.append_stmt(stmt)
def declare(self) :
- self.class_code.compile()
- exec(self.class_code.exec_string, self.globalCtx, self.localCtx)
-
- def __str__(self) :
- return self.class_code.exec_string
-
- # p : Since it is often useful to be able to look at the code
- # that is generated interactively, this function provides
- # a shorthand for "print str(some_exec_code_instance)", which
- # gives a reasonable nice look at the contents of the
- # exec_code object.
- def p(self) :
- print str(self)
+ self.class_code.execute()
self.services = {} # DBus service created
self.serviceAgents = {} # Instantiated DBus class previously generated dynamically, for now, one by classname
self.servicePendingCalls = {} # JS methods called (and waiting for a Success/error response), containing 'methodId', (successCB, errorCB)
+ self.localCtx = locals()
+ self.globalCtx = globals()
def proxyObject(self, busName, serviceName, objectName):
errorCB(result)
else:
errorCB()
+ self.servicePendingCalls[methodId] = None
else:
- print "No methodID %s !!" % (methodId)
-
+ print "No methodID %s !!" % (methodId)
+
+ def jsonEncodeTupleKeyDict(self, data):
+ ndict = dict()
+ # creates new dictionary with the original tuple converted to json string
+ dataLen = len(data)
+ string = ""
+ for index in range(dataLen):
+ for key in data[index]:
+ value = data[index][key]
+ print "key=" + key
+ print "value=" + str(value)
+ nkey = str(key)
+ nvalue = ""
+ print "JSON key=" + nkey
+ if (isinstance(value, dbus.Array)):
+ # Searching dbus byte in array...
+ ValueLen = len(value)
+ nvalue = []
+ for indexValue in range(ValueLen):
+ a = value[indexValue]
+ if (isinstance(a, dbus.Byte)):
+ a = int(value[indexValue])
+ nvalue.append(a)
+ else:
+ nvalue = str(value[indexValue])
+
+ print "JSON value=" + str(nvalue)
+ ndict[nkey] = nvalue
+
+ return ndict
def srvCB(self, name, async_succes_cb, async_error_cb, *args):
methodId = self.srvName + "#" + self.agentObjectPath + "#" + name
cb = { 'successCB': async_succes_cb,
'errorCB': async_error_cb}
- self.servicePendingCalls[methodId] = cb
- factory.dispatch(methodId, json.dumps(args))
-
+ self.servicePendingCalls[methodId] = cb
+
+ if (len(args) > 0):
+ print "Received args=%s" % (str(args))
+ else:
+ print "No args received"
+
+ try:
+ print "factory.dispatch(methodId=%s, args=%s)" % (methodId, json.dumps(args))
+ factory.dispatch(methodId, json.dumps(args))
+ return
+ except Exception, e :
+ print "Error=%s" % (str(e))
+
+ print "Trying to decode dbus.Dictionnary..."
+ try:
+ params = self.jsonEncodeTupleKeyDict(args)
+ print "factory.dispatch(methodId=%s, args=%s)" % (methodId, params)
+ factory.dispatch(methodId, params)
+ return
+ except Exception, e :
+ print "Error=%s" % (str(e))
+
+ print "Trying to pass args as string..."
+ try:
+ print "factory.dispatch(methodId=%s, args=%s)" % (methodId, str(args))
+ factory.dispatch(methodId, str(args))
+ return
+ except Exception, e :
+ print "Error=%s" % (str(e))
+
@exportRpc
def serviceAdd(self, list):
'''
self.srvName = list[1]
if (self.services.has_key(self.srvName) == False):
self.services[self.srvName] = dbus.service.BusName(name = self.srvName, bus = self.bus)
- return self.srvName
+ return self.srvName
@exportRpc
def serviceRelease(self, list):
'''
arguments: busName, srvName
'''
- busName = list[0]
- self.bus = cache.dbusConnexion( busName['name'] )
- self.srvName = list[1]
+ self.srvName = list[0]
if (self.services.has_key(self.srvName) == True):
- exe_str = "self.services['" + self.srvName +"']"
- exec (exe_str, globals(), locals())
+ self.services.pop(self.srvName)
return self.srvName
else:
raise Exception(self.srvName + " do not exist")
xmlTemplate = list[1]
self.className = re.sub('/', '_', self.agentObjectPath[1:])
if (self.dynDBusClasses.has_key(self.className) == False):
- self.dynDBusClasses[self.className] = dynDBusClass(self.className, globals(), locals())
+ self.dynDBusClasses[self.className] = dynDBusClass(self.className, self.globalCtx, self.localCtx)
self.dynDBusClasses[self.className].createDBusServiceFromXML(xmlTemplate)
+ self.dynDBusClasses[self.className].declare()
+
+ ## Class already exist, instanciate it if not already instanciated
+ if (self.serviceAgents.has_key(self.className) == False):
+ self.serviceAgents[self.className] = eval(self.className + "(self.bus, callback=self.srvCB, objName=self.agentObjectPath, busName=self.srvName)", self.globalCtx, self.localCtx)
- # For Debug only
- if (1):
- if (1): ## Force deletion
- if os.access('./MyDbusClass.py', os.R_OK) == True:
- os.remove('./MyDbusClass.py')
-
- if os.access('./MyDbusClass.py', os.R_OK) == False:
- f = open('./MyDbusClass.py', 'w')
- f.write(self.dynDBusClasses[self.className].class_code.exec_string)
- f.close()
-# self.dynDBusClass[className].p()
- self.dynDBusClasses[self.className].declare()
-
- if (self.serviceAgents.has_key(self.className) == False):
- exe_str = "self.serviceAgents['" + self.className +"'] = " + self.className + "(self.bus, callback=self.srvCB, objName=self.agentObjectPath, busName=self.srvName)"
- exec (exe_str, globals(), locals())
- return (self.agentObjectPath)
- else:
- raise Exception(self.agentObjectPath + " already exist !!")
+ self.serviceAgents[self.className].add_to_connection()
+ return (self.agentObjectPath)
@exportRpc
def serviceDelAgent(self, list):
agentObjectPath = list[0]
className = re.sub('/', '_', agentObjectPath[1:])
- if (self.serviceAgents.has_key(className)):
- exe_str = "self.serviceAgents['" + className +"'] = None"
- exec (exe_str, globals(), locals())
- return (self.className)
+ if (self.serviceAgents.has_key(className)):
+ self.serviceAgents[self.className].remove_from_connection()
+ self.serviceAgents.pop(self.className)
else:
- raise Exception(agentObjectPath + "doesn't exist!")
+ raise Exception(agentObjectPath + " doesn't exist!")
+
+ return (agentObjectPath)
@exportRpc
def getVersion(self):
projects / contrib / cloudeebus.git / blobdiff