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 82 matching lines @@
     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."""
 
+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 440 matching lines @@
 
     Args:
       requested_types: A list of sync data types from ALL_TYPES.
         Permanent items of only these types will be created.
     """
     for spec in self._PERMANENT_ITEM_SPECS:
       if spec.sync_type in requested_types:
         self._CreatePermanentItem(spec)
 
   def ResetStoreBirthday(self):
+<<<<<<< HEAD
     """Resets the store birthday to a random value."""
+=======
+    """Resets the store birthday to a random value.
+    """
+>>>>>>> fix.

[Raghu Simha, 2011/08/05 18:04:52]

Merge.

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

Done.

     # TODO(nick): uuid.uuid1() is better, but python 2.5 only.
     self.store_birthday = '%0.30f' % random.random()
 
   def StoreBirthday(self):
+<<<<<<< HEAD
     """Gets the store birthday."""
+=======
+    """Gets the store birthday.
+    """
+>>>>>>> fix.

[Raghu Simha, 2011/08/05 18:04:52]

Merge.

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

Done.

     return self.store_birthday
 
   def GetChanges(self, sieve):
     """Get entries which have changed, oldest first.
 
     The returned entries are limited to being _BATCH_SIZE many.  The entries
     are returned in strict version order.
 
     Args:
       sieve: An update sieve to use to filter out updates the client
@@ skipping 291 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.StoreBirthday() != request.store_birthday:
       raise StoreBirthdayError
 
+  def CheckTransientError(self):
+    """Raises Transiet error if |transient_error| variable is set."""

[Raghu Simha, 2011/08/05 18:04:52]

s/Transiet/Transient/

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

Done.

+    if self.transient_error == True:
+      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.ResetStoreBirthday()
     return (
         200,
         '<html><title>Birthday error</title><H1>Birthday error</H1></html>')
 
+<<<<<<< HEAD
+=======
+  def HandleSetTransientError(self):
+    self.transient_error = True
+    return (
+        200,
+        '<html><title>Transient error</title><H1>Transient error</H1></html>')
+
+>>>>>>> fix.

[Raghu Simha, 2011/08/05 18:04:52]

Merge.

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

Done.

   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, 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)