X-Git-Url: http://git.onelab.eu/?p=myslice.git;a=blobdiff_plain;f=manifold%2Fmanifoldapi.py;h=1ba0db4275bb8806bf785959c3f468844437cafa;hp=504e1829f99f717538b8787621564e507e6ed727;hb=1710230d6c76a139ae890d16767458cb8543ea35;hpb=bdc9578767df176902d19e6d94e1aacf6ef921a9 diff --git a/manifold/manifoldapi.py b/manifold/manifoldapi.py index 504e1829..1ba0db42 100644 --- a/manifold/manifoldapi.py +++ b/manifold/manifoldapi.py @@ -3,27 +3,47 @@ import xmlrpclib from myslice.config import Config -from manifoldresult import ManifoldResult, ManifoldCode +from django.contrib import messages +from manifoldresult import ManifoldResult, ManifoldCode, ManifoldException +from manifold.core.result_value import ResultValue debug=False debug=True +def mytruncate (obj, l): + # we will add '..' + l1=l-2 + repr="%s"%obj + return (repr[:l1]+'..') if len(repr)>l1 else repr + class ManifoldAPI: def __init__(self, auth=None, cainfo=None): - config = Config() self.auth = auth self.cainfo = cainfo self.errors = [] self.trace = [] self.calls = {} self.multicall = False - self.url = config.manifold_url + config = Config() + self.url = config.manifold_url() self.server = xmlrpclib.Server(self.url, verbose=False, allow_none=True) def __repr__ (self): return "ManifoldAPI[%s]"%self.url + # a one-liner to give a hint of what the return value looks like + def _print_result (self, result): + if not result: print "[no/empty result]" + elif isinstance (result,str): print "result is '%s'"%result + elif isinstance (result,list): print "result is a %d-elts list"%len(result) + elif isinstance (result,dict): + print "result is a dict with %d keys : %s"%(len(result),result.keys()) + for (k,v) in result.iteritems(): + if v is None: continue + print '+++',k,':',mytruncate (v,60) + else: print "[dont know how to display result] %s"%result + # xxx temporary code for scaffolding a ManifolResult on top of an API that does not expose error info # as of march 2013 we work with an API that essentially either returns the value, or raises # an xmlrpclib.Fault exception with always the same 8002 code @@ -32,55 +52,66 @@ class ManifoldAPI: # a SESSION_EXPIRED code def __getattr__(self, methodName): def func(*args, **kwds): - if (debug): - print "entering ManifoldAPI.%s"%methodName, - print "args",args, - print "kwds",kwds try: - result=getattr(self.server, methodName)(self.auth, *args, **kwds) - ### attempt to cope with old APIs and new APIs - if isinstance (result, dict) and 'code' in result: - # this sounds like a result from a new API, leave it untouched - pass - else: - if debug: - print '<=== backend call', methodName, args, kwds - print '.... ctd', 'Authmethod=',self.auth['AuthMethod'], self.url,'->', - if not result: print "[no/empty result]" - elif isinstance (result,str): print "result is '%s'"%result - elif isinstance (result,list): print "result is a %d-elts list"%len(result) - else: print "[dont know how to display result]" - return ManifoldResult (code=ManifoldCode.SUCCESS, value=result) - except xmlrpclib.Fault, error: - ### xxx this is very rough for now - # until we have some agreement about how the API calls should return error conditions - # in some less unpolite way than this anonymous exception, we assume it's a problem with the session - # that needs to be refreshed - if error.faultCode == 8002: - reason="most likely your session has expired" - reason += " (the manifold API has no unambiguous error reporting mechanism yet)" - return ManifoldResult (code=ManifoldCode.SESSION_EXPIRED, output=reason) - else: - reason="xmlrpclib.Fault with faultCode = %s (not taken as session expired)"%error.faultCode - return ManifoldResult (code=ManifoldCode.UNKNOWN_ERROR, output=reason) + if debug: + print "====> ManifoldAPI.%s"%methodName,"url",self.url + print "=> auth",self.auth + print "=> args",args,"kwds",kwds + annotations = { + 'authentication': self.auth + } + args += (annotations,) + result=getattr(self.server, methodName)(*args, **kwds) + if debug: + print '<==== backend call %s(*%s,**%s) returned'%(methodName,args,kwds), + print '.ctd. Authmethod=',self.auth['AuthMethod'], self.url,'->', + self._print_result(result) + print '===== ManifoldAPI call done' + + return ResultValue(**result) + except Exception,error: - print "ManifoldAPI: unexpected exception",error - return ManifoldResult (code=ManifoldCode.UNKNOWN_ERROR, output="%s"%error) + print "** MANIFOLD API ERROR **" + if "Connection refused" in error: + raise ManifoldException ( ManifoldResult (code=ManifoldCode.SERVER_UNREACHABLE, + output="%s answered %s"%(self.url,error))) + # otherwise + print "====> ERROR On ManifoldAPI.%s"%methodName,"auth",self.auth,"args",args,"kwds",kwds + import traceback + traceback.print_exc() + if debug: print "KO (unexpected exception)",error + print '===== ManifoldAPI call exiting' + raise ManifoldException ( ManifoldResult (code=ManifoldCode.UNKNOWN_ERROR, output="%s"%error) ) + return func - def send_manifold_query (self, query): - (action,subject)= (query.action,query.subject) - # use e.g. self.Get rather than self.server.Get so we use the __getattr__ code - if action=='get': -# this makes the backend to squeak and one can't login anymore... -# return self.Get(subject, query.filters, query.timestamp, query.fields) - return self.Get(subject, query.filters, {}, query.fields) - elif action=='update': - answer=self.Update(subject, query.filters, query.params, query.fields) - if not isinstance (answer, ManifoldResult): print "UNEXECPECTED answer", answer - return answer - else: - warning="WARNING: ManifoldAPI.send_manifold_query: %s not implemented for now"%action - print warning - print 3 - return ManifoldResult(code=ManifoldCode.NOT_IMPLEMENTED, output=warning) +def _execute_query(request, query, manifold_api_session_auth): + manifold_api = ManifoldAPI(auth=manifold_api_session_auth) + print "-"*80 + print query + print query.to_dict() + print "-"*80 + result = manifold_api.forward(query.to_dict()) + if result['code'] == 2: + raise Exception, 'Error running query: %r' % result + + if result['code'] == 1: + print "WARNING" + print result['description'] + + # XXX Handle errors + #Error running query: {'origin': [0, 'XMLRPCAPI'], 'code': 2, 'description': 'No such session: No row was found for one()', 'traceback': 'Traceback (most recent call last):\n File "/usr/local/lib/python2.7/dist-packages/manifold/core/xmlrpc_api.py", line 68, in xmlrpc_forward\n user = Auth(auth).check()\n File "/usr/local/lib/python2.7/dist-packages/manifold/auth/__init__.py", line 245, in check\n return self.auth_method.check()\n File "/usr/local/lib/python2.7/dist-packages/manifold/auth/__init__.py", line 95, in check\n raise AuthenticationFailure, "No such session: %s" % e\nAuthenticationFailure: No such session: No row was found for one()\n', 'type': 2, 'ts': None, 'value': None} + + return result['value'] + +def execute_query(request, query): + if not 'manifold' in request.session or not 'auth' in request.session['manifold']: + raise Exception, "User not authenticated" + manifold_api_session_auth = request.session['manifold']['auth'] + return _execute_query(request, query, manifold_api_session_auth) + +def execute_admin_query(request, query): + config = Config() + admin_user, admin_password = config.manifold_admin_user_password() + admin_auth = {'AuthMethod': 'password', 'Username': admin_user, 'AuthString': admin_password} + return _execute_query(request, query, admin_auth)