def _sort_property(sort):
"""Returns a datastore_query.PropertyOrder based on 'sort'."""
if sort == 'created_ts':
return datastore_query.PropertyOrder(
'__key__', datastore_query.PropertyOrder.ASCENDING)
return datastore_query.PropertyOrder(
sort, datastore_query.PropertyOrder.DESCENDING)
def get(self):
limit = int(self.request.get('limit', 100))
cursor = datastore_query.Cursor(urlsafe=self.request.get('cursor'))
sort_by = self.request.get('sort_by', '__key__')
if sort_by not in self.ACCEPTABLE_BOTS_SORTS:
self.abort(400, 'Invalid sort_by query parameter')
if sort_by[0] == '-':
order = datastore_query.PropertyOrder(
sort_by[1:], datastore_query.PropertyOrder.DESCENDING)
else:
order = datastore_query.PropertyOrder(
sort_by, datastore_query.PropertyOrder.ASCENDING)
now = utils.utcnow()
cutoff = now - datetime.timedelta(
seconds=config.settings().bot_death_timeout_secs)
num_bots_busy_future = bot_management.BotInfo.query(
bot_management.BotInfo.is_busy == True).count_async()
num_bots_dead_future = bot_management.BotInfo.query(
bot_management.BotInfo.last_seen_ts < cutoff).count_async()
num_bots_quarantined_future = bot_management.BotInfo.query(
bot_management.BotInfo.quarantined == True).count_async()
num_bots_total_future = bot_management.BotInfo.query().count_async()
fetch_future = bot_management.BotInfo.query().order(
order).fetch_page_async(limit, start_cursor=cursor)
# TODO(maruel): self.request.host_url should be the default AppEngine url
# version and not the current one. It is only an issue when
# version-dot-appid.appspot.com urls are used to access this page.
version = bot_code.get_bot_version(self.request.host_url)
bots, cursor, more = fetch_future.get_result()
# Prefetch the tasks. We don't actually use the value here, it'll be
# implicitly used by ndb local's cache when refetched by the html template.
tasks = filter(None, (b.task for b in bots))
ndb.get_multi(tasks)
num_bots_busy = num_bots_busy_future.get_result()
num_bots_dead = num_bots_dead_future.get_result()
num_bots_quarantined = num_bots_quarantined_future.get_result()
num_bots_total = num_bots_total_future.get_result()
params = {
'bots': bots,
'current_version': version,
'cursor': cursor.urlsafe() if cursor and more else '',
'is_admin': acl.is_admin(),
'is_privileged_user': acl.is_privileged_user(),
'limit': limit,
'now': now,
'num_bots_alive': num_bots_total - num_bots_dead,
'num_bots_busy': num_bots_busy,
'num_bots_dead': num_bots_dead,
'num_bots_quarantined': num_bots_quarantined,
'sort_by': sort_by,
'sort_options': self.SORT_OPTIONS,
'xsrf_token': self.generate_xsrf_token(),
}
self.response.write(
template.render('swarming/restricted_botslist.html', params))
def _sort_property(sort):
"""Returns a datastore_query.PropertyOrder based on 'sort'."""
if sort not in ('created_ts', 'modified_ts', 'completed_ts',
'abandoned_ts'):
raise ValueError('Unexpected sort %r' % sort)
if sort == 'created_ts':
return datastore_query.PropertyOrder(
'__key__', datastore_query.PropertyOrder.ASCENDING)
return datastore_query.PropertyOrder(
sort, datastore_query.PropertyOrder.DESCENDING)
def order(self, *args):
# q.order(Eployee.name, -Employee.age)
if not args:
return self
orders = []
o = self.__orders
if o:
orders.append(o)
for arg in args:
if isinstance(arg, model.Property):
orders.append(datastore_query.PropertyOrder(arg._name, ASC))
elif isinstance(arg, datastore_query.Order):
orders.append(arg)
else:
assert False, arg
if not orders:
orders = None
elif len(orders) == 1:
orders = orders[0]
else:
orders = datastore_query.CompositeOrder(orders)
return self.__class__(kind=self.kind,
ancestor=self.ancestor,
filters=self.filters,
orders=orders)
def parse_gql(query_string):
"""Parse a GQL query string.
Args:
query_string: Full GQL query, e.g. 'SELECT * FROM Kind WHERE prop = 1'.
Returns:
A tuple (query, options, bindings) where query is a Query instance,
options a datastore_query.QueryOptions instance, and bindings a dict
mapping integers and strings to Binding instances.
"""
gql_qry = gql.GQL(query_string)
ancestor = None
flt = gql_qry.filters()
bindings = {}
filters = []
for ((name, op), values) in flt.iteritems():
op = op.lower()
if op == 'is' and name == gql.GQL._GQL__ANCESTOR:
assert len(values) == 1
[(func, args)] = values
ancestor = _args_to_val(func, args, bindings)
continue
assert op in _OPS.values()
for (func, args) in values:
val = _args_to_val(func, args, bindings)
filters.append(FilterNode(name, op, val))
if filters:
filters.sort() # For predictable tests.
filters = ConjunctionNode(filters)
else:
filters = None
orderings = gql_qry.orderings()
orders = []
for (name, direction) in orderings:
orders.append(datastore_query.PropertyOrder(name, direction))
if not orders:
orders = None
elif len(orders) == 1:
orders = orders[0]
else:
orders = datastore_query.CompositeOrder(orders)
qry = Query(kind=gql_qry._entity,
ancestor=ancestor,
filters=filters,
orders=orders)
offset = gql_qry.offset()
if offset < 0:
offset = None
limit = gql_qry.limit()
if limit < 0:
limit = None
options = QueryOptions(offset=offset, limit=limit)
return qry, options, bindings
def ordering_to_order(ordering):
name, direction = ordering
return datastore_query.PropertyOrder(name, direction)
def __pos__(self): # So you can write q.order(-cls.age, +cls.name). return datastore_query.PropertyOrder(self._name)
def __neg__(self):
return datastore_query.PropertyOrder(
self._name, datastore_query.PropertyOrder.DESCENDING)