manifold/manifoldquery.py

   1 import json
   2 import uuid
   3
   4 def uniqid ():
   5     return uuid.uuid4().hex
   6
   7 debug=False
   8 debug=True
   9
  10 class ManifoldQuery:
  11
  12     def __init__ (self, action=None, subject=None, timestamp='now',
  13                   filters=[], params=[], fields=[],
  14                   sort=None, limit=None, offset=None,
  15                   ):
  16         self.query_uuid=uniqid()
  17         # settable
  18         self.action=action
  19         self.subject=subject
  20         self.timestamp=timestamp
  21         self.filters=filters
  22         self.params=params
  23         self.fields=fields
  24         # xxx these are unused for now....
  25         self.sort=sort
  26         self.limit=limit
  27         self.offset=offset
  28         # internal data - likewise, this is unused as of yet, although we have
  29         # (untested) code below in analyze_subqueries to compute these..
  30         self.analyzed_query=None
  31         self.subqueries = {}
  32
  33     def __repr__ (self):
  34         result="Q: id=%(query_uuid)s - %(action)s on %(subject)s "%self.__dict__
  35         result += " with %d filters, %d fields"%(len(self.filters),len(self.params))
  36         return result
  37
  38     def to_json (self):
  39         query_uuid=self.query_uuid
  40         a=self.action
  41         s=self.subject
  42         t=self.timestamp
  43         f=json.dumps (self.filters)
  44         p=json.dumps (self.params)
  45         c=json.dumps (self.fields)
  46         # xxx unique can be removed, but for now we pad the js structure
  47         unique=0
  48
  49         aq = self.analyzed_query.to_json() if self.analyzed_query else 'null'
  50         # subqueries is a dictionary subject:query
  51         if not self.subqueries:
  52             sq="{}"
  53         else:
  54             sq=", ".join ( [ "'%s':%s" % (subject, subquery.to_json())
  55                       for (subject, subquery) in self.subqueries.iteritems()])
  56             sq="{%s}"%sq
  57
  58         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()
  59         if debug: print 'ManifoldQuery.to_json:',result
  60         return result
  61
  62     # this builds a ManifoldQuery object from a dict as received from javascript through its ajax request
  63     # we use a json-encoded string - see manifold.js for the sender part
  64     # e.g. here's what I captured from the server's output
  65     # manifoldproxy.proxy: request.POST <QueryDict: {u'json': [u'{"action":"get","subject":"resource","timestamp":"latest","filters":[["slice_hrn","=","ple.inria.omftest"]],"params":[],"fields":["hrn","hostname"],"unique":0,"query_uuid":"436aae70a48141cc826f88e08fbd74b1","analyzed_query":null,"subqueries":{}}']}>
  66     def fill_from_POST (self, POST_dict):
  67         try:
  68             json_string=POST_dict['json']
  69             dict=json.loads(json_string)
  70             for (k,v) in dict.iteritems():
  71                 setattr(self,k,v)
  72         except:
  73             print "Could not decode incoming ajax request as a Query, POST=",POST_dict
  74             if (debug):
  75                 import traceback
  76                 traceback.print_exc()
  77
  78     # not used yet ..
  79     def analyze_subqueries(self):
  80         analyzed_query = ManifoldQuery()
  81         analyzed_query.query_uuid = self.query_uuid
  82         analyzed_query.action = self.action
  83         analyzed_query.subject = self.subject
  84         analyzed_query.timestamp = self.timestamp
  85
  86         # analyse query filters
  87         # filter syntax : ['key', 'oparation', 'value']
  88         for filter in self.filters:
  89             key = filter[0]
  90             operation = filter[1]
  91             value = filter[2]
  92             if '.' in key:
  93                 parts=key.split('.')
  94                 subject = parts[0]
  95                 field = parts[1]
  96                 if not analyzed_query.subqueries[subject]:
  97                     subquery = ManifoldQuery()
  98                     subquery.action = self.action
  99                     subquery.subject = subject
 100                     subquery.timestamp = self.timestamp
 101                     analyzed_query.subqueries[subject] = subquery
 102
 103                 analyzed_query.subqueries[subject].filters.append([field, operation, value])
 104             else:
 105                 analyzed_query.filters.append(filter)
 106
 107         # analyse query params
 108         # params syntax : params = {'param1': value1, 'param2': value2, ...}
 109         for param in self.params.keys():
 110             if '.' in param:
 111                 parts=param.split('.')
 112                 subject = parts[0]
 113                 field = parts[1]
 114                 if not analyzed_query.subqueries[subject]:
 115                     subquery = ManifoldQuery()
 116                     subquery.action = self.action
 117                     subquery.subject = subject
 118                     subquery.timestamp = self.timestamp
 119                     analyzed_query.subqueries[subject] = subquery
 120
 121                 analyzed_query.subqueries[subject].params[field] = self.params[param]
 122             else:
 123                 analyzed_query.params[param] = self.params[param]
 124
 125         # analyse query fields
 126         # fields syntax: fields = [element1, element2, ....]
 127         for element in self.fields:
 128             if '.' in element:
 129                 parts=element.split('.')
 130                 subject = parts[0]
 131                 field = parts[1]
 132                 if not analyzed_query.subqueries[subject]:
 133                     subquery = ManifoldQuery()
 134                     subquery.action = self.action
 135                     subquery.subject = subject
 136                     subquery.timestamp = self.timestamp
 137                     analyzed_query.subqueries[subject] = subquery
 138
 139                 analyzed_query.subqueries[subject].fields.append(field)
 140             else:
 141                 analyzed_query.fields.append(element)
 142
 143
 144         # default subqueries
 145         if analyzed_query.subject == 'slice':
 146             if not analyzed_query.subqueries['resource']:
 147                 subquery = ManifoldQuery()
 148                 subquery.action = self.action
 149                 subquery.subject = subject
 150                 subquery.timestamp = self.timestamp
 151                 analyzed_query.subqueries['resource'] = subquery
 152
 153             if not analyzed_query.subqueries['lease']:
 154                 subquery = ManifoldQuery()
 155                 subquery.action = self.action
 156                 subquery.subject = subject
 157                 subquery.timestamp = self.timestamp
 158                 analyzed_query.subqueries['lease'] = subquery
 159
 160
 161         self.analyzed_query = analyzed_query