-function ManifoldQuery(action, method, timestamp, filters, params, fields, unique, query_uuid, aq, sq) {
+function ManifoldQuery(action, subject, timestamp, filters, params, fields, unique, query_uuid, aq, sq) {
// get, update, delete, create
var action;
// slice, user, network...
- var method;
+ var subject;
// timestamp, now, latest(cache) : date of the results queried
var timestamp;
// key(field),op(=<>),value
/*-------------------------------------------------------------
Query properties are SQL like :
---------------------------------------------------------------
-SELECT fields FROM method WHERE filter;
-UPDATE method SET field=value WHERE filter; / returns SELECT
-DELETE FROM method WHERE filter
-INSERT INTO method VALUES(field=value)
+SELECT fields FROM subject WHERE filter;
+UPDATE subject SET field=value WHERE filter; / returns SELECT
+DELETE FROM subject WHERE filter
+INSERT INTO subject VALUES(field=value)
-------------------------------------------------------------*/
+ this.__repr = function (q) {
+ res = "ManyfoldQuery ";
+ res += " id=" + q.query_uuid;
+ res += " a=" + q.action;
+ res += " s=" + q.subject;
+ res += " ts=" + q.timestamp;
+ res += " flts=" + q.filters;
+ res += " flds=" + q.fields;
+ res += " prms=" + q.params;
+ return res;
+ }
+
this.clone = function() {
q = new ManifoldQuery();
return jQuery.extend(true, q, this);
return {'added':added, 'removed':removed};
}
this.to_hash = function() {
- return {'action': this.action, 'method': this.method, 'timestamp': this.timestamp,
+ return {'action': this.action, 'subject': this.subject, 'timestamp': this.timestamp,
'filters': this.filters, 'params': this.params, 'fields': this.fields};
}
this.analyze_subqueries = function() {
var q = new ManifoldQuery();
q.query_uuid = this.query_uuid;
q.action = this.action;
- q.method = this.method;
+ q.subject = this.subject;
q.timestamp = this.timestamp;
/* Filters */
var v = filter[2];
var pos = k.indexOf('.');
if (pos != -1) {
- var method = k.substr(0, pos);
+ var subject = k.substr(0, pos);
var field = k.substr(pos+1);
- if (jQuery.inArray(this.method, q.subqueries) == -1) {
- q.subqueries[this.method] = new ManifoldQuery();
- q.subqueries[this.method].action = this.action;
- q.subqueries[this.method].method = this.method;
- q.subqueries[this.method].timestamp = this.timestamp;
+ if (jQuery.inArray(this.subject, q.subqueries) == -1) {
+ q.subqueries[this.subject] = new ManifoldQuery();
+ q.subqueries[this.subject].action = this.action;
+ q.subqueries[this.subject].subject = this.subject;
+ q.subqueries[this.subject].timestamp = this.timestamp;
}
- q.subqueries[this.method].filters.push(Array(field, op, v));
+ q.subqueries[this.subject].filters.push(Array(field, op, v));
} else {
q.filters.push(this.filter);
}
jQuery.each(this.params, function(param, value) {
var pos = param.indexOf('.');
if (pos != -1) {
- var method = param.substr(0, pos);
+ var subject = param.substr(0, pos);
var field = param.substr(pos+1);
- if (jQuery.inArray(this.method, q.subqueries) == -1) {
- q.subqueries[this.method] = new ManifoldQuery();
- q.subqueries[this.method].action = this.action;
- q.subqueries[this.method].method = this.method;
- q.subqueries[this.method].timestamp = this.timestamp;
+ if (jQuery.inArray(this.subject, q.subqueries) == -1) {
+ q.subqueries[this.subject] = new ManifoldQuery();
+ q.subqueries[this.subject].action = this.action;
+ q.subqueries[this.subject].subject = this.subject;
+ q.subqueries[this.subject].timestamp = this.timestamp;
}
- q.subqueries[this.method].params[field] = value;
+ q.subqueries[this.subject].params[field] = value;
} else {
q.params[field] = value;
}
jQuery.each(this.fields, function(i, v) {
var pos = v.indexOf('.');
if (pos != -1) {
- var method = v.substr(0, pos);
+ var subject = v.substr(0, pos);
var field = v.substr(pos+1);
- if (jQuery.inArray(this.method, q.subqueries) == -1) {
- q.subqueries[this.method] = new ManifoldQuery();
- q.subqueries[this.method].action = this.action;
- q.subqueries[this.method].method = this.method;
- q.subqueries[this.method].timestamp = this.timestamp;
+ if (jQuery.inArray(this.subject, q.subqueries) == -1) {
+ q.subqueries[this.subject] = new ManifoldQuery();
+ q.subqueries[this.subject].action = this.action;
+ q.subqueries[this.subject].subject = this.subject;
+ q.subqueries[this.subject].timestamp = this.timestamp;
}
- q.subqueries[this.method].fields.push(field);
+ q.subqueries[this.subject].fields.push(field);
} else {
q.fields.push(v);
}
/* constructor */
this.action = action;
- this.method = method;
+ this.subject = subject;
this.timestamp = timestamp;
this.filters = filters;
this.params = params;
var query=manifold.find_query(tuple.query_uuid);
var hash=query.to_hash();
if (manifold.asynchroneous_debug)
- console.log ("sending POST on " + manifold.proxy_url + " iterating on " + tuple.query_uuid + " -> " + hash);
+ console.log ("sending POST on " + manifold.proxy_url + " with query= " + query.__repr(query));
jQuery.post(manifold.proxy_url, {'query': hash}, success_closure(query, tuple.id));
})
},
return func
def send_manifold_query (self, manifold_query):
- (action,method)= (manifold_query.action,manifold_query.method)
+ (action,subject)= (manifold_query.action,manifold_query.subject)
if action=='get':
- return self.server.Get(self.auth, method, manifold_query.filters, {}, manifold_query.fields)
+ return self.server.Get(self.auth, subject, manifold_query.filters, {}, manifold_query.fields)
# xxx...
else:
print "WARNING: ManifoldAPI.send_manifold_query: only 'get' implemented for now"
from manifold.manifoldquery import ManifoldQuery
from manifold.manifoldapi import ManifoldAPI
+debug=False
+debug=True
+
# add artificial delay in s
debug_spin=0
#debug_spin=1
return
try:
# translate incoming POST request into a query object
+ if debug: print 'manifoldproxy.proxy: request.POST',request.POST
manifold_query = ManifoldQuery()
manifold_query.fill_from_dict(request.POST)
# retrieve session for request
manifold_api_session_auth = request.session['manifold']['auth']
# actually forward
manifold_api= ManifoldAPI(auth=manifold_api_session_auth)
+ if debug: print 'manifoldproxy.proxy: sending to backend', manifold_query
answer=manifold_api.send_manifold_query (manifold_query)
if debug_spin:
import time
def uniqid ():
return uuid.uuid4().hex
+debug=False
+debug=True
+
class ManifoldQuery:
- def __init__ (self, action=None, method=None, timestamp='now',
+ def __init__ (self, action=None, subject=None, timestamp='now',
filters=[], params=[], fields=[],
sort=None, limit=None, offset=None,
):
self.query_uuid=uniqid()
# settable
self.action=action
- self.method=method
+ self.subject=subject
self.timestamp=timestamp
self.filters=filters
self.params=params
self.subqueries = {}
def __repr__ (self):
- result="Q: id=%(query_uuid)s - %(action)s on %(method)s "%self.__dict__
+ result="Q: id=%(query_uuid)s - %(action)s on %(subject)s "%self.__dict__
result += " with %d filters, %d fields"%(len(self.filters),len(self.params))
return result
def to_json (self):
query_uuid=self.query_uuid
a=self.action
- m=self.method
+ s=self.subject
t=self.timestamp
f=json.dumps (self.filters)
+ print 'filters f=',f
p=json.dumps (self.params)
c=json.dumps (self.fields)
# xxx unique can be removed, but for now we pad the js structure
unique=0
aq = self.analyzed_query.to_json() if self.analyzed_query else 'null'
- # subqueries is a dictionary method:query
+ # subqueries is a dictionary subject:query
if not self.subqueries:
sq="{}"
else:
- sq=", ".join ( [ "'%s':%s" % (method, subquery.to_json())
- for (method, subquery) in self.subqueries.iteritems()])
+ sq=", ".join ( [ "'%s':%s" % (subject, subquery.to_json())
+ for (subject, subquery) in self.subqueries.iteritems()])
sq="{%s}"%sq
- return """ new ManifoldQuery('%(a)s', '%(m)s', '%(t)s', %(f)s, %(p)s, %(c)s, %(unique)s, '%(query_uuid)s', %(aq)s, %(sq)s)"""%locals()
+ result= """ new ManifoldQuery('%(a)s', '%(s)s', '%(t)s', %(f)s, %(p)s, %(c)s, %(unique)s, '%(query_uuid)s', %(aq)s, %(sq)s)"""%locals()
+ if debug: print 'ManifoldQuery.to_json:',result
+ return result
# this builds a ManifoldQuery object from a dict as received from javascript through its ajax request
# e.g. here's what I captured from the server's output
- # incoming POST <QueryDict: {u'query[method]': [u'slice'], u'query[fields][]': [u'slice_hrn'], u'query[timestamp]': [u'latest'], u'query[action]': [u'get']}>
+ # incoming POST <QueryDict: {u'query[subject]': [u'slice'], u'query[fields][]': [u'slice_hrn'], u'query[timestamp]': [u'latest'], u'query[action]': [u'get']}>
def fill_from_dict (self, d):
for key in d.keys():
- for arg in ['action', 'method', 'filters', 'fields', 'timestamp', 'params']:
+ for arg in ['action', 'subject', 'filters', 'fields', 'timestamp', 'params']:
if arg in key:
# dirty hack around fields; fields must be a list
if arg == 'fields':
analyzed_query = ManifoldQuery()
analyzed_query.query_uuid = self.query_uuid
analyzed_query.action = self.action
- analyzed_query.method = self.method
+ analyzed_query.subject = self.subject
analyzed_query.timestamp = self.timestamp
# analyse query filters
operation = filter[1]
value = filter[2]
if '.' in key:
- method = key.split('.')[0]
- field = key.split('.')[1]
- if not analyzed_query.subqueries[method]:
+ parts=key.split('.')
+ subject = parts[0]
+ field = parts[1]
+ if not analyzed_query.subqueries[subject]:
subquery = ManifoldQuery()
subquery.action = self.action
- subquery.method = method
+ subquery.subject = subject
subquery.timestamp = self.timestamp
- analyzed_query.subqueries[method] = subquery
+ analyzed_query.subqueries[subject] = subquery
- analyzed_query.subqueries[method].filters.append([field, operation, value])
+ analyzed_query.subqueries[subject].filters.append([field, operation, value])
else:
analyzed_query.filters.append(filter)
# params syntax : params = {'param1': value1, 'param2': value2, ...}
for param in self.params.keys():
if '.' in param:
- method = param.split('.')[0]
- field = param.split('.')[1]
- if not analyzed_query.subqueries[method]:
+ parts=param.split('.')
+ subject = parts[0]
+ field = parts[1]
+ if not analyzed_query.subqueries[subject]:
subquery = ManifoldQuery()
subquery.action = self.action
- subquery.method = method
+ subquery.subject = subject
subquery.timestamp = self.timestamp
- analyzed_query.subqueries[method] = subquery
+ analyzed_query.subqueries[subject] = subquery
- analyzed_query.subqueries[method].params[field] = self.params[param]
+ analyzed_query.subqueries[subject].params[field] = self.params[param]
else:
analyzed_query.params[param] = self.params[param]
# fields syntax: fields = [element1, element2, ....]
for element in self.fields:
if '.' in element:
- method = element.split('.')[0]
- field = element.split('.')[1]
- if not analyzed_query.subqueries[method]:
+ parts=element.split('.')
+ subject = parts[0]
+ field = parts[1]
+ if not analyzed_query.subqueries[subject]:
subquery = ManifoldQuery()
subquery.action = self.action
- subquery.method = method
+ subquery.subject = subject
subquery.timestamp = self.timestamp
- analyzed_query.subqueries[method] = subquery
+ analyzed_query.subqueries[subject] = subquery
- analyzed_query.subqueries[method].fields.append(field)
+ analyzed_query.subqueries[subject].fields.append(field)
else:
analyzed_query.fields.append(element)
# default subqueries
- if analyzed_query.method == 'slice':
+ if analyzed_query.subject == 'slice':
if not analyzed_query.subqueries['resource']:
subquery = ManifoldQuery()
subquery.action = self.action
- subquery.method = method
+ subquery.subject = subject
subquery.timestamp = self.timestamp
analyzed_query.subqueries['resource'] = subquery
if not analyzed_query.subqueries['lease']:
subquery = ManifoldQuery()
subquery.action = self.action
- subquery.method = method
+ subquery.subject = subject
subquery.timestamp = self.timestamp
analyzed_query.subqueries['lease'] = subquery
padding: 0em 0em 0em 1em;
}
-div.method {
+div.subject {
padding: 10px;
background-color: #fafafa;
border-top: solid 1px black;
});
ofs = '[' + ofs + ']';
- output += 'pp srv.call("' + mixed_case(query.action) +'", auth, "' + query.method + '", "' + query.timestamp + '", ' + ifs + ', ' + ofs + ')';
+ output += 'pp srv.call("' + mixed_case(query.action) +'", auth, "' + query.subject + '", "' + query.timestamp + '", ' + ifs + ', ' + ofs + ')';
var output = '<pre class="brush: ruby; toolbar: false;">' + output + "</pre>";
return output;
});
ofs = '[' + ofs + ']';
- output += 'srv.' + mixed_case(query.action) + '(auth, "' + query.method + '", ' + ifs + ', {}, ' + ofs + ')';
+ output += 'srv.' + mixed_case(query.action) + '(auth, "' + query.subject + '", ' + ifs + ', {}, ' + ofs + ')';
var output = '<pre class="brush: python; toolbar: false;">' + output + "</pre>";
return output;
}
page = Page(request)
slices_query = ManifoldQuery (action='get',
- method='slice',
+ subject='slice',
timestamp='latest',
fields=['slice_hrn'],
+ filters=[],
# xxx filter : should filter on the slices the logged user can see
# we don't have the user's hrn yet
# in addition this currently returns all slices anyways
page = Page(request)
main_query = ManifoldQuery (action='get',
- method='resource',
+ subject='resource',
timestamp='latest',
fields=['hrn','hostname'],
filters= [ [ 'slice_hrn', '=', 'ple.inria.', ] ],
get : function () {
return MANIFOLD_METADATA;
},
- // returns all fields of a given method
- fields : function (method) {
+ // returns all fields of a given subject
+ fields : function (subject) {
var result=new Array();
- jQuery.each(MANIFOLD_METADATA, function(m,obj){
- if(m==method){
+ jQuery.each(MANIFOLD_METADATA, function(s,obj){
+ if(s==subject){
jQuery.each(obj['column'], function(i,f){
result.push(f);
});
return result;
},
// returns all properties of a given field
- field : function (method, field) {
+ field : function (subject, field) {
var result=new Array();
- jQuery.each(MANIFOLD_METADATA, function(m,obj){
- if(m==method){
+ jQuery.each(MANIFOLD_METADATA, function(s,obj){
+ if(s==subject){
jQuery.each(obj['column'], function(i,f){
if(f['column']==field){
result.push(f);
});
return result[0];
},
- // returns the value of a property from a field within a method (type of object : resource,node,lease,slice...)
- property : function (method, field, property) {
+ // returns the value of a property from a field within a subject (type of object : resource,node,lease,slice...)
+ property : function (subject, field, property) {
var result=null;
- jQuery.each(MANIFOLD_METADATA, function(m,obj){
- if(m==method){
+ jQuery.each(MANIFOLD_METADATA, function(s,obj){
+ if(s==subject){
jQuery.each(obj['column'], function(i,f){
if(f['column']==field){
result=f[property];
results = manifold_api.Get('metadata:table', [], [], fields)
for res in results:
- method = res['table']
- self._metadata[method] = res
+ subject = res['table']
+ self._metadata[subject] = res
request.session['metadata'] = self._metadata
javascript = "var MANIFOLD_METADATA =" + json.dumps(self._metadata) + ";"
self.add_js_chunks(javascript)
- def metadata_get_fields(self, method):
- return self._metadata[method]['column'].sort()
+ def metadata_get_fields(self, subject):
+ return self._metadata[subject]['column'].sort()
def expose_js_manifold_config (self):
self.add_js_chunks(Config.manifold_js_export())
git://git.onelab.eu / unfold.git / commitdiff