X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=PLC%2FAPI.py;h=6e59d560bfed2751951bb67af3a053d24fc65d25;hb=c00cb94ae221df67a821efcc1640e88854e63ece;hp=e3e084d9642ccc856fb64d49c4e41461a77f6a28;hpb=4c3c1eea2e69949fab2f993841eec7abfe07ee3f;p=plcapi.git diff --git a/PLC/API.py b/PLC/API.py index e3e084d..6e59d56 100644 --- a/PLC/API.py +++ b/PLC/API.py @@ -5,22 +5,76 @@ # Mark Huang # # Copyright (C) 2004-2006 The Trustees of Princeton University -# $Id: API.py,v 1.5 2006/10/24 13:47:35 mlhuang Exp $ # +import os import sys import traceback +import string import xmlrpclib -def dump(self, value, write): +# See "2.2 Characters" in the XML specification: +# +# #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] +# avoiding +# [#x7F-#x84], [#x86-#x9F], [#xFDD0-#xFDDF] + +invalid_codepoints = range(0x0, 0x8) + [0xB, 0xC] + range(0xE, 0x1F) +# broke with f24, somehow we get a unicode as an incoming string to be translated +str_xml_escape_table = string.maketrans("".join((chr(x) for x in invalid_codepoints)), + "?" * len(invalid_codepoints)) +# loosely inspired from +# http://www.terminally-incoherent.com/blog/2010/05/06/character-mapping-must-return-integer-none-or-unicode/ +unicode_xml_escape_table = { invalid : u"?" for invalid in invalid_codepoints} + +def xmlrpclib_escape(s, replace = string.replace): + """ + xmlrpclib does not handle invalid 7-bit control characters. This + function augments xmlrpclib.escape, which by default only replaces + '&', '<', and '>' with entities. + """ + + # This is the standard xmlrpclib.escape function + s = replace(s, "&", "&") + s = replace(s, "<", "<") + s = replace(s, ">", ">",) + + # Replace invalid 7-bit control characters with '?' + if isinstance(s, str): + return s.translate(str_xml_escape_table) + else: + return s.translate(unicode_xml_escape_table) + +def test_xmlrpclib_escape(): + inputs = [ + # full ASCII + "".join( (chr(x) for x in range(128))), + # likewise but as a unicode string up to 256 + u"".join( (unichr(x) for x in range(256))), + ] + for input in inputs: + print "==================== xmlrpclib_escape INPUT" + print type(input), '->', input + print "==================== xmlrpclib_escape OUTPUT" + print xmlrpclib_escape(input) + +def xmlrpclib_dump(self, value, write): """ xmlrpclib cannot marshal instances of subclasses of built-in types. This function overrides xmlrpclib.Marshaller.__dump so that any value that is an instance of one of its acceptable types is marshalled as that type. + + xmlrpclib also cannot handle invalid 7-bit control characters. See + above. """ + # Use our escape function + args = [self, value, write] + if isinstance(value, (str, unicode)): + args.append(xmlrpclib_escape) + try: # Try for an exact match first f = self.dispatch[type(value)] @@ -28,14 +82,14 @@ def dump(self, value, write): # Try for an isinstance() match for Type, f in self.dispatch.iteritems(): if isinstance(value, Type): - f(self, value, write) + f(*args) return raise TypeError, "cannot marshal %s objects" % type(value) else: - f(self, value, write) + f(*args) # You can't hide from me! -xmlrpclib.Marshaller._Marshaller__dump = dump +xmlrpclib.Marshaller._Marshaller__dump = xmlrpclib_dump # SOAP support is optional try: @@ -50,9 +104,33 @@ except ImportError: from PLC.Config import Config from PLC.Faults import * import PLC.Methods +import PLC.Accessors + +def import_deep(name): + mod = __import__(name) + components = name.split('.') + for comp in components[1:]: + mod = getattr(mod, comp) + return mod class PLCAPI: - methods = PLC.Methods.methods + + # flat list of method names + native_methods = PLC.Methods.native_methods + + # other_methods_map : dict {methodname: fullpath} + # e.g. 'Accessors' -> 'PLC.Accessors.Accessors' + other_methods_map={} + for subdir in [ 'Accessors' ]: + path="PLC."+subdir + # scan e.g. PLC.Accessors.__all__ + pkg = __import__(path).__dict__[subdir] + for modulename in getattr(pkg,"__all__"): + fullpath=path+"."+modulename + for method in getattr(import_deep(fullpath),"methods"): + other_methods_map[method] = fullpath + + all_methods = native_methods + other_methods_map.keys() def __init__(self, config = "/etc/planetlab/plc_config", encoding = "utf-8"): self.encoding = encoding @@ -69,7 +147,39 @@ class PLCAPI: from PLC.PostgreSQL import PostgreSQL self.db = PostgreSQL(self) else: - raise PLCAPIError, "Unsupported database type " + config.PLC_DB_TYPE + raise PLCAPIError, "Unsupported database type " + self.config.PLC_DB_TYPE + + # Aspects modify the API by injecting code before, after or + # around method calls. -- http://github.com/baris/pyaspects/blob/master/README + # + if self.config.PLC_RATELIMIT_ENABLED: + from aspects import apply_ratelimit_aspect + apply_ratelimit_aspect() + + if getattr(self.config, "PLC_NETCONFIG_ENABLED", False): + from aspects.netconfigaspects import apply_netconfig_aspect + apply_netconfig_aspect() + + # Enable Caching. Only for GetSlivers for the moment. + # TODO: we may consider to do this in an aspect like the ones above. + try: + if self.config.PLC_GETSLIVERS_CACHE: + getslivers_cache = True + except AttributeError: + getslivers_cache = False + + if getslivers_cache: + os.environ['DJANGO_SETTINGS_MODULE']='plc_django_settings' + from cache_utils.decorators import cached + from PLC.Methods.GetSlivers import GetSlivers + + @cached(7200) + def cacheable_call(cls, auth, node_id_or_hostname): + return cls.raw_call(auth, node_id_or_hostname) + + GetSlivers.call = cacheable_call + + def callable(self, method): """ @@ -77,16 +187,20 @@ class PLCAPI: """ # Look up method - if method not in self.methods: + if method not in self.all_methods: raise PLCInvalidAPIMethod, method # Get new instance of method try: classname = method.split(".")[-1] - module = __import__("PLC.Methods." + method, globals(), locals(), [classname]) + if method in self.native_methods: + fullpath="PLC.Methods." + method + else: + fullpath=self.other_methods_map[method] + module = __import__(fullpath, globals(), locals(), [classname]) return getattr(module, classname)(self) except ImportError, AttributeError: - raise PLCInvalidAPIMethod, method + raise PLCInvalidAPIMethod, "import error %s for %s" % (AttributeError,fullpath) def call(self, source, method, *args): """ @@ -138,3 +252,19 @@ class PLCAPI: data = buildSOAP(kw = {'%sResponse' % method: {'Result': result}}, encoding = self.encoding) return data + + def handle_json(self, source, data): + """ + Handle a JSON request + """ + method, args = json.loads(data) + try: + result = self.call(source, method, *args) + except Exception, e: + result = str(e) + + return json.dumps(result) + +# one simple unit test +if __name__ == '__main__': + test_xmlrpclib_escape()