-import time
-
from django.contrib.auth.models import User
from manifoldapi.manifoldapi import ManifoldAPI, ManifoldException, ManifoldResult
from portal.actions import authority_check_pis
-# from unfold.sessioncache import SessionCache
-
-# Name my backend 'ManifoldBackend'
class ManifoldBackend:
# Create an authentication method
request = token['request']
auth = {'AuthMethod': 'password', 'Username': email, 'AuthString': password}
- api = ManifoldAPI(auth)
+ api = ManifoldAPI(config.manifold_url(), auth)
sessions_result = api.forward(Query.create('local:session').to_dict())
sessions = sessions_result.ok_value()
if not sessions:
# Manifold API Python interface
import copy
-import xmlrpclib
import ssl
+# for python3
+try: import xmlrpclib
+except: import xmlrpc.client as xmlrpclib
+
from django.contrib import messages
from django.shortcuts import redirect
from manifold.core.result_value import ResultValue
from manifoldresult import ManifoldResult, ManifoldCode, ManifoldException, truncate_result
-# from unfold.sessioncache import SessionCache
-
-from myslice.settings import config, logger
+# being available from the outside (r2lab django web site)
+try:
+ from myslice.settings import logger
+except:
+ import logging
+ logger = logging.getLogger('manifoldapi')
+
class ManifoldAPI:
- def __init__(self, auth=None, cainfo=None):
+ def __init__(self, url, auth=None, cainfo=None):
+ self.url = url
self.auth = auth
self.cainfo = cainfo
self.errors = []
self.trace = []
self.calls = {}
self.multicall = False
- self.url = config.manifold_url()
# Manifold uses a self signed certificate
# https://www.python.org/dev/peps/pep-0476/
return func
-def _execute_query(request, query, manifold_api_session_auth):
+def _execute_query(url, request, query, manifold_api_session_auth):
- manifold_api = ManifoldAPI(auth = manifold_api_session_auth)
+ manifold_api = ManifoldAPI(url, auth = manifold_api_session_auth)
logger.debug("MANIFOLD -> QUERY : {}".format(" ".join(str(query).split())))
result = manifold_api.forward(query.to_dict())
manifold_api_session_auth = request.session['manifold']['auth']
- return _execute_query(request, query, manifold_api_session_auth)
+ from myslice.settings import config
+ url = config.manifold_url()
+ return _execute_query(url, request, query, manifold_api_session_auth)
def execute_admin_query(request, query):
+ # xxx config
+ from myslice.settings import config
+ url = config.manifold_url()
+
admin_user, admin_password = config.manifold_admin_user_password()
if not admin_user or not admin_password:
logger.error("""CONFIG: you need to setup admin_user and admin_password in myslice.ini
Some functions won't work properly until you do so""")
admin_auth = {'AuthMethod': 'password', 'Username': admin_user, 'AuthString': admin_password}
- return _execute_query(request, query, admin_auth)
+
+ return _execute_query(url, request, query, admin_auth)
#from manifoldapi.manifoldquery import ManifoldQuery
from manifold.core.query import Query
from manifold.core.result_value import ResultValue
-from manifoldapi import ManifoldAPI
-from manifoldresult import ManifoldException
+from manifoldapi import ManifoldAPI
+from manifoldresult import ManifoldException
# from unfold.sessioncache import SessionCache
# myslice/urls.py
# as well as
# static/js/manifold.js
-def proxy (request,format):
+def proxy(request, format):
+ from myslice.settings import config
+ url = config.manifold_url()
+ return _proxy(url, request, format)
+
+def _proxy(url, request, format):
"""the view associated with /manifold/proxy/ with the query passed using POST"""
# expecting a POST
return HttpResponse (json.dumps({'code':0,'value':[]}), content_type="application/json")
# actually forward
- manifold_api= ManifoldAPI(auth=manifold_api_session_auth)
+ manifold_api= ManifoldAPI(url, auth=manifold_api_session_auth)
# for the benefit of the python code, manifoldAPI raises an exception if something is wrong
# however in this case we want to propagate the complete manifold result to the js world
import json
import os.path
-from manifoldresult import ManifoldResult
-from manifoldapi import ManifoldAPI
+from manifoldresult import ManifoldResult
+from manifoldapi import ManifoldAPI
from django.contrib import messages
class MetaData:
- def __init__ (self, auth):
+ def __init__ (self, url, auth):
+ self.url = url
self.auth=auth
self.hash_by_object={}
def fetch (self, request):
- manifold_api = ManifoldAPI(self.auth)
+ manifold_api = ManifoldAPI(self.url, self.auth)
fields = ['table', 'column.name', 'column.qualifier', 'column.type',
'column.is_array', 'column.description', 'column.default', 'key', 'capability']
#fields = ['table', 'column.column',
--- /dev/null
+import os
+import sys
+
+path = '/var/www/myslice'
+if path not in sys.path:
+ sys.path.append(path)
+
+os.environ['DJANGO_SETTINGS_MODULE'] = 'myslice.settings'
+
+import django.core.handlers.wsgi
+application = django.core.handlers.wsgi.WSGIHandler()
+
metadata_auth = {'AuthMethod':'anonymous'}
- metadata = MetaData (metadata_auth)
+ from myslice.settings import config
+ url = config.manifold_url()
+ metadata = MetaData (url, metadata_auth)
metadata.fetch(self.request)
# store it for next time
manifold['metadata']=metadata