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

appengine/isolate/handlers_api.py

 # Copyright 2012 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.
 
 """This module defines Isolate Server frontend url handlers."""
 
 import binascii
 import collections
 import datetime
 import hashlib
@@ skipping 147 matching lines @@
       "server_app_version": "138-193f1f3",
     }
   """
 
   # This handler is called to get XSRF token, there's nothing to enforce yet.
   xsrf_token_enforce_on = ()
 
   @auth.require(acl.isolate_readable)
   def post(self):
     """Responds with access token and server version."""
+    logging.error('Unexpected old client')
     try:
       request = json.loads(self.request.body)
       client_protocol = str(request['protocol_version'])
       client_app_version = str(request['client_app_version'])
       pusher = request.get('pusher', True)
       fetcher = request.get('fetcher', True)
     except (ValueError, KeyError) as exc:
       return self.send_error(
           'Invalid body of /handshake call.\nError: %s.' % exc)
 
@@ skipping 189 matching lines @@
           entry_info, namespace,
           http_verb='PUT',
           uploaded_to_gs=False,
           expiration=self.DEFAULT_LINK_EXPIRATION)
       finalize_url = None
     return upload_url, finalize_url
 
   @auth.require(acl.isolate_writable)
   def post(self, namespace):
     """Reads body with items to upload and replies with URLs to upload to."""
+    logging.error('Unexpected old client')
     if not re.match(r'^%s$' % model.NAMESPACE_RE, namespace):
       self.send_error(
           'Invalid namespace; allowed keys must pass regexp "%s"' %
           model.NAMESPACE_RE)
 
     # Parse a body into list of EntryInfo objects.
     try:
       entries = self.parse_request(self.request.body)
     except ValueError as err:
       return self.send_error(
@@ skipping 29 matching lines @@
   Can produce 5 types of responses:
     * HTTP 200: the content is in response body as octet-stream.
     * HTTP 206: partial content is in response body.
     * HTTP 302: http redirect to a file with the content.
     * HTTP 404: content is not available, response body is a error message.
     * HTTP 416: requested byte range can not be satisfied.
   """
 
   @auth.require(acl.isolate_readable)
   def get(self, namespace, hash_key):  #pylint: disable=W0221
+    logging.error('Unexpected old client')
     # Parse 'Range' header if it's present to extract initial offset.
     # Only support single continuous range from some |offset| to the end.
     offset = 0
     range_header = self.request.headers.get('range')
     if range_header:
       match = re.match(r'bytes=(\d+)-', range_header)
       if not match:
         return self.send_error(
             'Unsupported byte range.\n\'%s\'.' % range_header, http_code=416)
       offset = int(match.group(1))
@@ skipping 81 matching lines @@
         is_isolated,
         uploaded_to_gs,
     ])
     mac = hmac.new(secret_key, digestmod=hashlib.sha1)
     mac.update(data_to_sign)
     return mac.hexdigest()
 
   @auth.require(acl.isolate_writable)
   def post(self, namespace, hash_key):
     """POST is used when finalizing upload to GS."""
+    logging.error('Unexpected old client')
     return self.handle(namespace, hash_key)
 
   @auth.require(acl.isolate_writable)
   def put(self, namespace, hash_key):
     """PUT is used when uploading directly to datastore via this handler."""
     return self.handle(namespace, hash_key)
 
   def handle(self, namespace, hash_key):
     """Handles this request."""
     # Extract relevant request parameters.
@@ skipping 170 matching lines @@
         RetrieveContentHandler),
     webapp2.Route(
         r'/content-gs/store%s' % namespace_key,
         StoreContentHandler,
         name='store-gs'),
   ]
   # Routes added to WSGIApplication only a dev mode.
   if utils.is_local_dev_server():
     routes.extend(gcs.URLSigner.switch_to_dev_mode())
   return routes