Add alerts on all old APIs on both Swarming and Isolate servers.

appengine/swarming/handlers_api.py

 # Copyright 2014 The Swarming Authors. All rights reserved.
 # Use of this source code is governed by the Apache v2.0 license that can be
 # found in the LICENSE file.
 
 """Swarming client REST APIs handlers."""
 
 import base64
 import datetime
 import json
 import logging
@@ skipping 70 matching lines @@
 
 
 ### New Client APIs.
 
 
 class ClientApiListHandler(auth.ApiHandler):
   """All query handlers"""
 
   @auth.public
   def get(self):
+    logging.error('Unexpected old client')
     # Hard to make it any simpler.
     prefix = '/swarming/api/v1/client/'
     data = {
       r.template[len(prefix):]: process_doc(r.handler) for r in get_routes()
       if r.template.startswith(prefix) and hasattr(r.handler, 'get')
     }
     self.send_response(data)
 
 
 class ClientHandshakeHandler(auth.ApiHandler):
@@ skipping 12 matching lines @@
   """
 
   # This handler is called to get XSRF token, there's nothing to enforce yet.
   xsrf_token_enforce_on = ()
 
   EXPECTED_KEYS = frozenset()
 
   @auth.require_xsrf_token_request
   @auth.require(acl.is_bot_or_user)
   def post(self):
+    logging.error('Unexpected old client')
     request = self.parse_body()
     log_unexpected_keys(
         self.EXPECTED_KEYS, request, self.request, 'client', 'keys')
     data = {
       # This access token will be used to validate each subsequent request.
       'server_version': utils.get_app_version(),
       'xsrf_token': self.generate_xsrf_token(),
     }
     self.send_response(data)
 
 
 class ClientTaskResultBase(auth.ApiHandler):
   """Implements the common base code for task related query APIs."""
 
   def get_result_key(self, task_id):
+    logging.error('Unexpected old client')
     # TODO(maruel): Users can only request their own task. Privileged users can
     # request any task.
     key = None
     summary_key = None
     try:
       key = task_pack.unpack_result_summary_key(task_id)
       summary_key = key
     except ValueError:
       try:
         key = task_pack.unpack_run_result_key(task_id)
         summary_key = task_pack.run_result_key_to_result_summary_key(key)
       except ValueError:
         self.abort_with_error(400, error='Invalid key')
     return key, summary_key
 
   def get_result_entity(self, task_id):
     key, _ = self.get_result_key(task_id)
     result = key.get()
     if not result:
       self.abort_with_error(404, error='Task not found')
     return result
 
 
 class ClientTaskResultHandler(ClientTaskResultBase):
   """Task's result meta data"""
 
   @auth.require(acl.is_bot_or_user)
   def get(self, task_id):
+    logging.error('Unexpected old client')
     result = self.get_result_entity(task_id)
     self.send_response(utils.to_json_encodable(result))
 
 
 class ClientTaskResultRequestHandler(ClientTaskResultBase):
   """Task's request details"""
 
   @auth.require(acl.is_bot_or_user)
   def get(self, task_id):
+    logging.error('Unexpected old client')
     _, summary_key = self.get_result_key(task_id)
     request_key = task_pack.result_summary_key_to_request_key(summary_key)
     self.send_response(utils.to_json_encodable(request_key.get()))
 
 
 class ClientTaskResultOutputHandler(ClientTaskResultBase):
   """Task's output for a single command"""
 
   @auth.require(acl.is_bot_or_user)
   def get(self, task_id, command_index):
+    logging.error('Unexpected old client')
     result = self.get_result_entity(task_id)
     output = result.get_command_output_async(int(command_index)).get_result()
     if output:
       output = output.decode('utf-8', 'replace')
     # JSON then reencodes to ascii compatible encoded strings, which explodes
     # the size.
     data = {
       'output': output,
     }
     self.send_response(utils.to_json_encodable(data))
 
 
 class ClientTaskResultOutputAllHandler(ClientTaskResultBase):
   """All output from all commands in a task"""
 
   @auth.require(acl.is_bot_or_user)
   def get(self, task_id):
+    logging.error('Unexpected old client')
     result = self.get_result_entity(task_id)
     # JSON then reencodes to ascii compatible encoded strings, which explodes
     # the size.
     data = {
       'outputs': [
         i.decode('utf-8', 'replace') if i else i
         for i in result.get_outputs()
       ],
     }
     self.send_response(utils.to_json_encodable(data))
@@ skipping 16 matching lines @@
         'completed', 'completed_success', 'completed_failure', 'bot_died',
         'expired', 'canceled'. Defaults to 'all'.
 
   In particular, one of `name`, `tag` or `state` can be used
   exclusively.
   """
   EXPECTED = {'cursor', 'limit', 'name', 'sort', 'state', 'tag'}
 
   @auth.require(acl.is_privileged_user)
   def get(self):
+    logging.error('Unexpected old client')
     extra = frozenset(self.request.GET) - self.EXPECTED
     if extra:
       self.abort_with_error(
           400,
           error='Extraneous query parameters. Did you make a typo? %s' %
           ','.join(sorted(extra)))
 
     # Use a similar query to /user/tasks.
     name = self.request.get('name')
     tags = self.request.get_all('tag')
@@ skipping 42 matching lines @@
     'completed_success',
     'expired',
     'pending',
     'pending_running',
     'running',
     'timed_out',
   }
 
   @auth.require(acl.is_privileged_user)
   def get(self):
+    logging.error('Unexpected old client')
     extra = frozenset(self.request.GET) - self.EXPECTED
     if extra:
       self.abort_with_error(
           400,
           error='Extraneous query parameters. Did you make a typo? %s' %
           ','.join(sorted(extra)))
 
     interval = self.request.get('interval', 24 * 3600)
     state = self.request.get('state', 'all')
     tags = self.request.get_all('tag')
@@ skipping 25 matching lines @@
 class ClientApiBots(auth.ApiHandler):
   """Bots known to the server"""
 
   ACCEPTABLE_FILTERS = (
     'quarantined',
     'is_dead',
   )
 
   @auth.require(acl.is_privileged_user)
   def get(self):
+    logging.error('Unexpected old client')
     now = utils.utcnow()
     limit = int(self.request.get('limit', 1000))
     filter_by = self.request.get('filter')
     if filter_by and filter_by not in self.ACCEPTABLE_FILTERS:
       self.abort_with_error(400, error='Invalid filter query parameter')
 
     q = bot_management.BotInfo.query()
 
     if not filter_by:
       q = q.order(bot_management.BotInfo.key)
@@ skipping 23 matching lines @@
       'now': now,
     }
     self.send_response(utils.to_json_encodable(data))
 
 
 class ClientApiBot(auth.ApiHandler):
   """Bot's meta data"""
 
   @auth.require(acl.is_privileged_user)
   def get(self, bot_id):
+    logging.error('Unexpected old client')
     bot = bot_management.get_info_key(bot_id).get()
     if not bot:
       self.abort_with_error(404, error='Bot not found')
     now = utils.utcnow()
     self.send_response(utils.to_json_encodable(bot.to_dict_with_now(now)))
 
   @auth.require(acl.is_admin)
   def delete(self, bot_id):
     # Only delete BotInfo, not BotRoot, BotEvent nor BotSettings.
     bot_key = bot_management.get_info_key(bot_id)
     found = False
     if bot_key.get():
       bot_key.delete()
       found = True
     self.send_response({'deleted': bool(found)})
 
 
 class ClientApiBotTask(auth.ApiHandler):
   """Tasks executed on a specific bot"""
 
   @auth.require(acl.is_privileged_user)
   def get(self, bot_id):
+    logging.error('Unexpected old client')
     limit = int(self.request.get('limit', 100))
     cursor = datastore_query.Cursor(urlsafe=self.request.get('cursor'))
     run_results, cursor, more = task_result.TaskRunResult.query(
         task_result.TaskRunResult.bot_id == bot_id).order(
             -task_result.TaskRunResult.started_ts).fetch_page(
                 limit, start_cursor=cursor)
     now = utils.utcnow()
     data = {
       'cursor': cursor.urlsafe() if cursor and more else None,
       'items': run_results,
       'limit': limit,
       'now': now,
     }
     self.send_response(utils.to_json_encodable(data))
 
 
 class ClientApiServer(auth.ApiHandler):
   """Server details"""
 
   @auth.require(acl.is_privileged_user)
   def get(self):
+    logging.error('Unexpected old client')
     data = {
       'bot_version': bot_code.get_bot_version(self.request.host_url),
     }
     self.send_response(utils.to_json_encodable(data))
 
 
 class ClientRequestHandler(auth.ApiHandler):
   """Creates a new request, returns the task id.
 
   Argument:
@@ skipping 29 matching lines @@
   # task itself, e.g. what to run.
   _REQUIRED_PROPERTIES_KEYS= frozenset(
       ['commands', 'data', 'dimensions', 'env', 'execution_timeout_secs',
       'io_timeout_secs'])
   _EXPECTED_PROPERTIES_KEYS = frozenset(
       ['commands', 'data', 'dimensions', 'env', 'execution_timeout_secs',
       'grace_period_secs', 'idempotent', 'io_timeout_secs'])
 
   @auth.require(acl.is_bot_or_user)
   def post(self):
+    logging.error('Unexpected old client')
     data = self.parse_body()
     msg = log_unexpected_subset_keys(
         self._EXPECTED_DATA_KEYS, self._REQUIRED_DATA_KEYS, data, self.request,
         'client', 'request keys')
     if msg:
       self.abort_with_error(400, error=msg)
     data_properties = data['properties']
     msg = log_unexpected_subset_keys(
         self._EXPECTED_PROPERTIES_KEYS, self._REQUIRED_PROPERTIES_KEYS,
         data_properties, self.request, 'client', 'request properties keys')
@@ skipping 39 matching lines @@
     self.send_response(utils.to_json_encodable(data))
 
 
 class ClientCancelHandler(auth.ApiHandler):
   """Cancels a task."""
 
   # TODO(maruel): Allow privileged users to cancel, and users to cancel their
   # own task.
   @auth.require(acl.is_admin)
   def post(self):
+    logging.error('Unexpected old client')
     request = self.parse_body()
     task_id = request.get('task_id')
     summary_key = task_pack.unpack_result_summary_key(task_id)
 
     ok, was_running = task_scheduler.cancel_task(summary_key)
     out = {
       'ok': ok,
       'was_running': was_running,
     }
     self.send_response(out)
@@ skipping 15 matching lines @@
           ClientTaskResultRequestHandler),
       ('/swarming/api/v1/client/task/<task_id:[0-9a-f]+>/output/'
         '<command_index:[0-9]+>',
           ClientTaskResultOutputHandler),
       ('/swarming/api/v1/client/task/<task_id:[0-9a-f]+>/output/all',
           ClientTaskResultOutputAllHandler),
       ('/swarming/api/v1/client/tasks', ClientApiTasksHandler),
       ('/swarming/api/v1/client/tasks/count', ClientApiTasksCountHandler),
   ]
   return [webapp2.Route(*i) for i in routes]