docs: def synchronize_resources(self):
          """Synchronize worker with CVX
  
          All database queries must occur while the sync lock is held. This
          tightly couples reads with writes and ensures that an older read
          does not result in the last write. Eg:
  
          Worker 1 reads (P1 created)
          Worder 2 reads (P1 deleted)
          Worker 2 writes (Delete P1 from CVX)
          Worker 1 writes (Create P1 on CVX)
  
          By ensuring that all reads occur with the sync lock held, we ensure
          that Worker 1 completes its writes before Worker2 is allowed to read.
          A failure to write results in a full resync and purges all reads from
          memory.
  
          It is also important that we compute resources to sync in reverse sync
          order in order to avoid missing dependencies on creation. Eg:
  
          If we query in sync order
          1. Query Instances -> I1 isn't there
          2. Query Port table -> Port P1 is there, connected to I1
          3. We send P1 to CVX without sending I1 -> Error raised
  
          But if we query P1 first:
          1. Query Ports P1 -> P1 is not there
          2. Query Instances -> find I1
          3. We create I1, not P1 -> harmless, mech driver creates P1
  
          Missing dependencies on deletion will helpfully result in the
          dependent resource not being created:
          1. Query Ports -> P1 is found
          2. Query Instances -> I1 not found
          3. Creating P1 fails on CVX
          """
          # Grab the sync lock
          if not self._rpc.sync_start():
              LOG.info("%(pid)s Failed to grab the sync lock",
                       {'pid': os.getpid()})
              greenthread.sleep(1)
              return
  
          for resource in self._resources_to_update:
              self.update_neutron_resource(resource)
          self._resources_to_update = list()
  
          # Sync any necessary resources.
          # We delete in reverse order and create in order to ensure that
          # dependent resources  are deleted before the resources they depend
          # on and created after them
          for resource_type in reversed(self.sync_order):
              resource_type.delete_cvx_resources()
          for resource_type in self.sync_order:
              resource_type.create_cvx_resources()
  
          # Release the sync lock
          self._rpc.sync_end()
  
          # Update local uuid if this was a full sync
          if self._synchronizing_uuid:
              LOG.info("%(pid)s Full sync for cvx uuid %(uuid)s complete",
                       {'uuid': self._synchronizing_uuid,
                        'pid': os.getpid()})
              self._cvx_uuid = self._synchronizing_uuid
              self._synchronizing_uuid = None