Python TarInfo.mtime方法代码示例

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
    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 )

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
    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 )

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
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 )

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
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

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
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()

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
    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

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
    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

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
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)

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
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)

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
 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)

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
 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)

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
 def test_change_info(self):
   # writing
   db = TarDB(dirname).open('r+')
   data_foo = '123'
   mtime = 12345
   info = TarInfo('foo')
   info.mtime = mtime
   db.add_record(info, data_foo)
   db.close()
   # reading
   db = TarDB(dirname).open('r+')
   info = db[0]
   self.assertEqual(info.mtime, mtime)
   db[0] = info
   db.close()
   return

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
 def test_tar_compatibility(self):
   # writing
   db = TarDB(dirname).open('r+')
   data_foo = '123'
   mtime = 12345
   info = TarInfo('foo')
   info.mtime = mtime
   db.add_record(info, data_foo)
   db.close()
   # reading with tarfile
   import tarfile
   tar = tarfile.TarFile(os.path.join(dirname, 'db00000.tar'))
   info = tar.next()
   data = tar.extractfile(info).read()
   self.assertEqual(data, data_foo)
   self.assertEqual(len(data), info.size)
   self.assertEqual(info.mtime, mtime)
   tar.close()
   return

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
 def add_str(self, name, content, ftype, mode, mtime=None,
             uid=None, gid=None, uname=None, gname=None):
     '''
     Add a string in memory as a file in tarball
     '''
     if isinstance(name, unicode):
         name = name.encode("UTF-8")
     ti = TarInfo(name)
     # set tarinfo attribute
     for v in ("name", "ftype", "mode", "mtime", "uid", "gid", "uname", "gname"):
         if vars()[v] is not None:
             vars(ti)[v] = vars()[v]
     # set mtime to current if not specified
     if mtime is None:
         ti.mtime = int(time())
     # unicode char is encoded in UTF-8, has changelog must be in UTF-8
     if isinstance(content, unicode):
         content = content.encode("UTF-8")
     ti.size = len(content) if content is not None else 0
     self.addfile(ti, StringIO(content))

# 需要导入模块: from tarfile import TarInfo [as 别名]
# 或者: from tarfile.TarInfo import mtime [as 别名]
    def get_image(self, image):
        if not image:
            raise APIError(HTTPError('500 Server Error'), None, explanation='Usage: image_export IMAGE [IMAGE...]')

        layers = []
        next_layer_id = image

        while next_layer_id:
            layer = normalizeimage(self._findlayer(next_layer_id), copy=True)
            layers.append(layer)
            next_layer_id = layers[-1][':parent_id']

        image_file = BytesIO()
        mtime = time()

        with tarfile_open(mode='w', fileobj=image_file) as image_tar_file:
            for layer in layers:
                ti_dir = TarInfo(layer[':id'])
                ti_dir.mtime = mtime
                ti_dir.mode = 0o755
                ti_dir.type = DIRTYPE
                image_tar_file.addfile(ti_dir)

                layer_tar_src_path = ospath_join(self._my_dir, 'data', layer[':short_id'], 'layer.tar')

                with open(layer_tar_src_path, 'rb') as layer_tar_src_file:
                    layer_tar_dst_path = '{}/layer.tar'.format(layer[':id'])
                    ti_layer = image_tar_file.gettarinfo(layer_tar_src_path, layer_tar_dst_path)
                    ti_layer.mtime = mtime
                    ti_layer.mode = 0o644
                    ti_layer.uid = ti_layer.gid = 0
                    ti_layer.uname = ti_layer.gname = ''
                    image_tar_file.addfile(ti_layer, fileobj=layer_tar_src_file)

        image_file.seek(0)

        return image_file