code: async def archive(self, record: ArchiveRecord):
          
          async with self.path_lock_ready:
              lock = self.path_locks.get(record.filepath)
  
              if lock is None:
                  lock = Lock()
                  self.path_locks[record.filepath] = lock
  
          # Skip writes when a given path is already locked
          if lock.locked():
              self.log.info("Skipping archive of %s", record.filepath)
              return
  
          async with lock:
              try:
                  async with self.session.create_client(
                      's3',
                      aws_secret_access_key=self.settings.s3_secret_access_key,
                      aws_access_key_id=self.settings.s3_access_key_id,
                      endpoint_url=self.settings.s3_endpoint_url,
                      region_name=self.settings.s3_region_name,
                  ) as client:
                      self.log.info("Processing storage write of %s", record.filepath)
                      file_key = s3_key(self.settings.workspace_prefix, record.filepath)
                      await client.put_object(
                          Bucket=self.settings.s3_bucket, Key=file_key, Body=record.content
                      )
                      self.log.info("Done with storage write of %s", record.filepath)
              except Exception as e:
                  self.log.error(
                      'Error while archiving file: %s %s', record.filepath, e, exc_info=True
                  )
docs: Process a record to write to storage.
  
          Acquire a path lock before archive. Writing to storage will only be
          allowed to a path if a valid `path_lock` is held and the path is not
          locked by another process.
  
          Parameters
          ----------
          record : ArchiveRecord
              A notebook and where it should be written to storage