Simulate transient error and verify exponential backoff.

net/tools/testserver/chromiumsync.py

 #!/usr/bin/python2.4
 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """An implementation of the server side of the Chromium sync protocol.
 
 The details of the protocol are described mostly by comments in the protocol
 buffer definition at chrome/browser/sync/protocol/sync.proto.
 """
@@ skipping 81 matching lines @@
   Attributes:
     datatypes: a list of the datatypes (python enum) needing migration.
   """
 
   def __init__(self, datatypes):
     self.datatypes = datatypes
 
 
 class StoreBirthdayError(Error):
   """The client sent a birthday that doesn't correspond to this server."""
 

[ncarter (slow), 2011/07/29 18:52:17]

The style guide requires 2 blank lines between top-level definitions (i.e. class
or function defs that aren't inside some other scope).

[lipalani1, 2011/08/05 21:33:57]

Done.

+class TransientError(Error):
+  """The client would be sent a transient error."""
+
 
 def GetEntryType(entry):
   """Extract the sync type from a SyncEntry.
 
   Args:
     entry: A SyncEntity protobuf object whose type to determine.
   Returns:
     An enum value from ALL_TYPES if the entry's type can be determined, or None
     if the type cannot be determined.
   Raises:
@@ skipping 795 matching lines @@
 
   def __init__(self):
     # The implementation supports exactly one account; its state is here.
     self.account = SyncDataModel()
     self.account_lock = threading.Lock()
     # Clients that have talked to us: a map from the full client ID
     # to its nickname.
     self.clients = {}
     self.client_name_generator = ('+' * times + chr(c)
         for times in xrange(0, sys.maxint) for c in xrange(ord('A'), ord('Z')))
+    self.transient_error = False
 
   def GetShortClientName(self, query):
     parsed = cgi.parse_qs(query[query.find('?')+1:])
     client_id = parsed.get('client_id')
     if not client_id:
       return '?'
     client_id = client_id[0]
     if client_id not in self.clients:
       self.clients[client_id] = self.client_name_generator.next()
     return self.clients[client_id]
 
   def CheckStoreBirthday(self, request):
     """Raises StoreBirthdayError if the request's birthday is a mismatch."""
     if not request.HasField('store_birthday'):
       return
     if self.account.store_birthday != request.store_birthday:
       raise StoreBirthdayError
 
+  def CheckTransientError(self):
+    """Raises Transiet error if |transient_error| variable is set."""

[ncarter (slow), 2011/07/29 18:52:17]

"Transiet" is a misspelling, you should probably say "TransientError" to
identify the exact exception.  Also, quoting a variable name with
|transient_error| is not customary good python style.

[lipalani1, 2011/08/05 21:33:57]

Done.

+    if self.transient_error == True:

[ncarter (slow), 2011/07/29 18:52:17]

Just say "if self.transient_error:".  While this is not exactly equivalent to
"== True"  -- it's different on inputs like "aa" or [False] or {1 : [1, "b"]} ,
all of which are True for the purposes of boolean contexts -- the convention in
python is to not check for equality, but instead allow variables to be evaluated
in the boolean context, as this is considered more readable.

[lipalani1, 2011/08/05 21:33:57]

Done.

+      raise TransientError
+
   def HandleMigrate(self, path):
     query = urlparse.urlparse(path)[4]
     code = 200
     self.account_lock.acquire()
     try:
       datatypes = [DataTypeStringToSyncTypeLoose(x)
                    for x in urlparse.parse_qs(query).get('type',[])]
       if datatypes:
         self.account.TriggerMigration(datatypes)
         response = 'Migrated datatypes %s' % (
             ' and '.join(SyncTypeToString(x).upper() for x in datatypes))
       else:
         response = 'Please specify one or more <i>type=name</i> parameters'
         code = 400
     except DataTypeIdNotRecognized, error:
       response = 'Could not interpret datatype name'
       code = 400
     finally:
       self.account_lock.release()
     return (code, '<html><title>Migration: %d</title><H1>%d %s</H1></html>' %
                 (code, code, response))
 
   def HandleCreateBirthdayError(self):
     self.account.store_birthday = '%0.30f' % random.random()
     return (
         200,
         '<html><title>Birthday error</title><H1>Birthday error</H1></html>')
 
+  def HandleSetTransientError(self):
+    self.transient_error = True
+    return (
+        200,
+        '<html><title>Transient error</title><H1>Transient error</H1></html>')
+
   def HandleCommand(self, query, raw_request):
     """Decode and handle a sync command from a raw input of bytes.
 
     This is the main entry point for this class.  It is safe to call this
     method from multiple threads.
 
     Args:
       raw_request: An iterable byte sequence to be interpreted as a sync
         protocol command.
     Returns:
       A tuple (response_code, raw_response); the first value is an HTTP
       result code, while the second value is a string of bytes which is the
       serialized reply to the command.
     """
     self.account_lock.acquire()
     def print_context(direction):
       print '[Client %s %s %s.py]' % (self.GetShortClientName(query), direction,
                                       __name__),
 
     try:
       request = sync_pb2.ClientToServerMessage()
       request.MergeFromString(raw_request)
       contents = request.message_contents
 
       response = sync_pb2.ClientToServerResponse()
       response.error_code = sync_pb2.ClientToServerResponse.SUCCESS
       self.CheckStoreBirthday(request)
       response.store_birthday = self.account.store_birthday
+      self.CheckTransientError();
 
       print_context('->')
 
       if contents == sync_pb2.ClientToServerMessage.AUTHENTICATE:
         print 'Authenticate'
         # We accept any authentication token, and support only one account.
         # TODO(nick): Mock out the GAIA authentication as well; hook up here.
         response.authenticate.user.email = 'syncjuser@chromium'
         response.authenticate.user.display_name = 'Sync J User'
       elif contents == sync_pb2.ClientToServerMessage.COMMIT:
@@ skipping 17 matching lines @@
       response.migrated_data_type_id[:] = [
           SyncTypeToProtocolDataTypeId(x) for x in error.datatypes]
       return (200, response.SerializeToString())
     except StoreBirthdayError as error:
       print_context('<-')
       print 'NOT_MY_BIRTHDAY'
       response = sync_pb2.ClientToServerResponse()
       response.store_birthday = self.account.store_birthday
       response.error_code = sync_pb2.ClientToServerResponse.NOT_MY_BIRTHDAY
       return (200, response.SerializeToString())
+    except TransientError as error:
+      print_context('<-')
+      print 'TRANSIENT_ERROR'
+      response.store_birthday = self.account.store_birthday
+      response.error_code = sync_pb2.ClientToServerResponse.TRANSIENT_ERROR
+      return (200, response.SerializeToString())
     finally:
       self.account_lock.release()
 
   def HandleCommit(self, commit_message, commit_response):
     """Respond to a Commit request by updating the user's account state.
 
     Commit attempts stop after the first error, returning a CONFLICT result
     for any unattempted entries.
 
     Args:
@@ skipping 54 matching lines @@
 
     update_sieve.CheckMigrationState()
 
     new_timestamp, entries, remaining = self.account.GetChanges(update_sieve)
 
     update_response.changes_remaining = remaining
     for entry in entries:
       reply = update_response.entries.add()
       reply.CopyFrom(entry)
     update_sieve.SaveProgress(new_timestamp, update_response)