def _addToArchive(output, filename, archive):
    output.seek(0)
    xmlInfo = TarInfo(filename)
    xmlInfo.size = len(output.getbuffer())
    xmlInfo.mtime = time.time()
    archive.addfile(xmlInfo,output)    
    output.close()

    def _dump_files(self, tar):
        """
        Dump all uploaded media to the archive.
        """

        # Loop through all models and find FileFields
        for model in apps.get_models():

            # Get the name of all file fields in the model
            field_names = []
            for field in model._meta.fields:
                if isinstance(field, models.FileField):
                    field_names.append(field.name)

            # If any were found, loop through each row
            if len(field_names):
                for row in model.objects.all():
                    for field_name in field_names:
                        field = getattr(row, field_name)
                        if field:
                            field.open()
                            info = TarInfo(field.name)
                            info.size = field.size
                            tar.addfile(info, field)
                            field.close()

    def put(self, content, filename="", file_hash=""):
        """ Store file information in hashed tree """ 

        if not filename and not file_hash:
            raise ValueError('Filename or FileHash is mandatory')

        if filename:
            # File accesibility
            if not os.path.exists(filename):
                raise IOError('Unaccesible file %s', filename)

            # Calc hash
            file_hash = self._get_hash(filename)
        
        if not file_hash:
            raise ValueError('Hash of file is mandatory')

        # Get file path for hash
        path, tarfile, hashed_filename = self._get_path(file_hash)

        # Create file path
        try:
            os.makedirs(path)
        except WindowsError: 
            pass
        except OSError:
            pass

        # Open tarfile
        if self.external_compressor:
            # External compressor is not suited for adding files.
            raise ValueError('You cannot use external compressor for write files')

        with TarFile.open(name=os.path.join(path, tarfile), mode='a') as tar:
            with FileLock(os.path.join(path, tarfile)) as lock:
                # Test if file already exists into tarfile
                try:
                    tar.getmember(hashed_filename)
                    raise ValueError('Member already exists')
                except KeyError:
                    pass
                except:
                    raise
            
                data = self.encoder.encode(content)
                if self.internal_compressor:
                    data = self.internal_compressor.compress(data)

                data_file = StringIO(data)

                mtime = time.time() 
                ti = TarInfo(hashed_filename)
                ti.size = data_file.len
                ti.mtime = mtime 

                tar.addfile(tarinfo=ti, fileobj=data_file)

                tar.close()

        return file_hash

def GetTarInfo(filename, filetype=DIRTYPE, mode=0755):
    """Create information for tar files"""
    tarinfo = TarInfo(path.basename(filename))
    tarinfo.type = filetype
    tarinfo.mode = mode
    tarinfo.mtime = time()
    return tarinfo

    def move_certs(self, paths):
        self.log.info("Staging internal ssl certs for %s", self._log_name)
        yield self.pull_image(self.move_certs_image)
        # create the volume
        volume_name = self.format_volume_name(self.certs_volume_name, self)
        # create volume passes even if it already exists
        self.log.info("Creating ssl volume %s for %s", volume_name, self._log_name)
        yield self.docker('create_volume', volume_name)

        # create a tar archive of the internal cert files
        # docker.put_archive takes a tarfile and a running container
        # and unpacks the archive into the container
        nb_paths = {}
        tar_buf = BytesIO()
        archive = TarFile(fileobj=tar_buf, mode='w')
        for key, hub_path in paths.items():
            fname = os.path.basename(hub_path)
            nb_paths[key] = '/certs/' + fname
            with open(hub_path, 'rb') as f:
                content = f.read()
            tarinfo = TarInfo(name=fname)
            tarinfo.size = len(content)
            tarinfo.mtime = os.stat(hub_path).st_mtime
            tarinfo.mode = 0o644
            archive.addfile(tarinfo, BytesIO(content))
        archive.close()
        tar_buf.seek(0)

        # run a container to stage the certs,
        # mounting the volume at /certs/
        host_config = self.client.create_host_config(
            binds={
                volume_name: {"bind": "/certs", "mode": "rw"},
            },
        )
        container = yield self.docker('create_container',
            self.move_certs_image,
            volumes=["/certs"],
            host_config=host_config,
        )

        container_id = container['Id']
        self.log.debug(
            "Container %s is creating ssl certs for %s",
            container_id[:12], self._log_name,
        )
        # start the container
        yield self.docker('start', container_id)
        # stage the archive to the container
        try:
            yield self.docker(
                'put_archive',
                container=container_id,
                path='/certs',
                data=tar_buf,
            )
        finally:
            yield self.docker('remove_container', container_id)
        return nb_paths

 def generate_tar(entries):
     tar_buf = BytesIO()
     tar_file = TarFile(mode="w", fileobj=tar_buf)
     for path, contents in entries.items():
         tar_info = TarInfo(name=path)
         tar_info.size = len(contents)
         tar_file.addfile(tar_info, fileobj=BytesIO(contents))
     return BytesIO(tar_buf.getvalue())

def addFile(tar, dest, file, file_size):
    if dest not in written_files:
        info = TarInfo(dest)
        info.size = file_size
        info.mtime = now
        info.mode = 0777
        tar.addfile(info, fileobj=file)
        written_files.add(dest)

 def _dump_meta(self, tar):
     """
     Dump metadata to the archive.
     """
     data = MixedIO()
     dump({'version': __version__}, data)
     info = TarInfo('meta.json')
     info.size = data.rewind()
     tar.addfile(info, data)

    def create_dir(self, path):
        """Create a directory within the tarfile.

        :param path: the path to put the directory at.
        """
        tarinfo = TarInfo(name=path)
        tarinfo.type = DIRTYPE
        tarinfo.mode = 0755
        self._set_defaults(tarinfo)
        self.addfile(tarinfo)

def writeDataFile( self, filename, text, content_type, subdir=None ):

    """ See IExportContext.
    """
    mod_time = time.time()
    if subdir is not None:
        elements = subdir.split('/')
        parents = filter(None, elements)
        while parents:
            dirname = os.path.join(*parents)
            try:
                self._archive.getmember(dirname+'/')
            except KeyError:
                info = TarInfo(dirname)
                info.size = 0
                info.mode = 509
                info.mtime = mod_time
                info.type = DIRTYPE
                self._archive.addfile(info, StringIO())
            parents = parents[:-1]

        filename = '/'.join( ( subdir, filename ) )

    stream = StringIO( text )
    info = TarInfo( filename )
    info.size = len( text )
    info.mode = 436
    info.mtime = mod_time
    self._archive.addfile( info, stream )

    def given_download(self, payload: Dict[str, bytes], compression: str):
        resource_id = '{}.tar.{}'.format(uuid4(), compression)
        download_filename = join(self._content_root, resource_id)

        with self.sync._open(download_filename, 'w') as archive:
            for filename, content in payload.items():
                tarinfo = TarInfo(filename)
                tarinfo.size = len(content)
                archive.addfile(tarinfo, BytesIO(content))

        self.email_server_client_mock.download.return_value = resource_id

def addString(tar, dest, string):
    if dest not in written_files:
        print dest, string
        info = TarInfo(dest)
        info.size = len(string)
        info.mtime = now
        info.mode = 0777
        file = StringIO(string)
        tar.addfile(info, fileobj=file)
        file.close()
        written_files.add(dest)

 def create_article(self, data, info=None):
   if not self._mode: raise TarCMS.TarCMSError('not open: %r' % self)
   if info is None:
     info = TarInfo()
   assert isinstance(info, TarInfo)
   aid = '%08x' % self._artdb.nextrecno()
   info.name = aid+info.name
   tid = self._add_corpus(info, data)
   assert aid == tid
   self._artdb.add_record(tid)
   return aid

 def _addMember(path, data, modtime):
     from tarfile import DIRTYPE
     elements = path.split('/')
     parents = filter(None, [elements[x] for x in range(len(elements))])
     for parent in parents:
         info = TarInfo()
         info.name = parent
         info.size = 0
         info.mtime = mod_time
         info.type = DIRTYPE
         archive.addfile(info, StringIO())
     _addOneMember(path, data, modtime)

    def _dump_db(self, tar):
        """
        Dump the rows in each model to the archive.
        """

        # Dump the tables to a MixedIO
        data = MixedIO()
        call_command('dumpdata', all=True, format='json', indent=self.attr.get('ARCHIVE_DB_INDENT'),
                                 exclude=self.attr.get('ARCHIVE_EXCLUDE'), stdout=data)
        info = TarInfo(DB_DUMP)
        info.size = data.rewind()
        tar.addfile(info, data)

    def create_file_from_string(self, filename, content):
        """Create a file with the contents passed as a string.

        :param filename: the path to put the file at inside the
            tarfile.
        :param content: the content to put in the created file.
        """
        tarinfo = TarInfo(name=filename)
        tarinfo.size = len(content)
        self._set_defaults(tarinfo)
        fileobj = StringIO(content)
        self.addfile(tarinfo, fileobj=fileobj)

 def _addMember(filename, data, modtime):
     from tarfile import DIRTYPE
     parents = filename.split('/')[:-1]
     while parents:
         path = '/'.join(parents) + '/'
         if path not in archive.getnames():
             info = TarInfo(path)
             info.type = DIRTYPE
             info.mtime = modtime
             archive.addfile(info)
         parents.pop()
     _addOneMember(filename, data, modtime)

 def write_package():
     tbs = ForgeClient.UPLOAD_TAR_BUFFER_SIZE
     with TarFile.open(mode="w|gz", fileobj=body, bufsize=tbs,
                       dereference=True) as tar:
         for file in files:
             self.debug("Sending %s", file)
             ti = TarInfo(file)
             fp = os.path.join(self.path, file)
             ti.size = os.path.getsize(fp)
             ti.mode = 0o666
             with open(fp, "rb") as fd:
                 tar.addfile(ti, fileobj=fd)
     body.close()

    def writeDataFile( self, filename, text, content_type, subdir=None ):

        """ See IExportContext.
        """
        if subdir is not None:
            filename = '/'.join( ( subdir, filename ) )

        parents = filename.split('/')[:-1]
        while parents:
            path = '/'.join(parents) + '/'
            if path not in self._archive.getnames():
                info = TarInfo(path)
                info.type = DIRTYPE
                # tarfile.filemode(0755) == '-rwxr-xr-x'
                info.mode = 0755
                info.mtime = time.time()
                self._archive.addfile(info)
            parents.pop()

        info = TarInfo(filename)
        if isinstance(text, str):
            stream = StringIO(text)
            info.size = len(text)
        elif isinstance(text, unicode):
            raise ValueError("Unicode text is not supported, even if it only "
                             "contains ascii. Please encode your data. See "
                             "GS 1.7.0 changes for more")
        else:
            # Assume text is a an instance of a class like
            # Products.Archetypes.WebDAVSupport.PdataStreamIterator, 
            # as in the case of ATFile
            stream = text.file
            info.size = text.size
        info.mtime = time.time()
        self._archive.addfile( info, stream )

    def writeDataFile( self, filename, text, content_type, subdir=None ):

        """ See IExportContext.
        """
        if subdir is not None:
            filename = '/'.join( ( subdir, filename ) )

        parents = filename.split('/')[:-1]
        while parents:
            path = '/'.join(parents) + '/'
            if path not in self._archive.getnames():
                info = TarInfo(path)
                info.type = DIRTYPE
                # tarfile.filemode(0755) == '-rwxr-xr-x'
                info.mode = 0755
                info.mtime = time.time()
                self._archive.addfile(info)
            parents.pop()

        info = TarInfo(filename)
        if isinstance(text, basestring):
            stream = StringIO(text)
            info.size = len(text)
        else:
            # Assume text is a an instance of a class like
            # Products.Archetypes.WebDAVSupport.PdataStreamIterator, 
            # as in the case of ATFile
            stream = text.file
            info.size = text.size
        info.mtime = time.time()
        self._archive.addfile( info, stream )