def stat(self, path, followlinks=0, path_is_real=False):
     if not path_is_real:
         virtpath = self.split_virtual_path(path)
         if (virtpath.search_name != '' and
             virtpath.search_name not in [r[0] for r in
                                          self.search_request.get_searches()]):
             # raise OSError like os.stat does
             raise OSError('No such file or directory: "%s"' % path)
         if virtpath.search_relpath == '/' or virtpath.search_relpath == '':
             return posix.stat_result((
                 self.dir_perm,
                 0,  # st_ino
                 0,  # st_dev
                 0,  # st_nlink
                 0,  # st_uid
                 0,  # st_gid
                 4096,  # st_size
                 0,  # st_atime
                 0,  # st_mtime
                 0,  # st_ctime
             ))
         real_path = self.real_path(virtpath)
     else:
         real_path = path
     if followlinks:
         s = os.stat(real_path)
     else:
         s = os.lstat(real_path)
     if stat.S_ISDIR(s.st_mode):
         mode = self.dir_perm
     elif stat.S_ISREG(s.st_mode):
         mode = self.file_perm
     return posix.stat_result((mode,) + s[1:])
Example #2
0
 def stat(self, path, followlinks=0, path_is_real=False):
     if not path_is_real:
         virtpath = self.split_virtual_path(path)
         if (virtpath.search_name != '' and virtpath.search_name
                 not in [r[0] for r in self.search_request.get_searches()]):
             # raise OSError like os.stat does
             raise OSError('No such file or directory: "%s"' % path)
         if virtpath.search_relpath == '/' or virtpath.search_relpath == '':
             return posix.stat_result((
                 self.dir_perm,
                 0,  # st_ino
                 0,  # st_dev
                 0,  # st_nlink
                 0,  # st_uid
                 0,  # st_gid
                 4096,  # st_size
                 0,  # st_atime
                 0,  # st_mtime
                 0,  # st_ctime
             ))
         real_path = self.real_path(virtpath)
     else:
         real_path = path
     if followlinks:
         s = os.stat(real_path)
     else:
         s = os.lstat(real_path)
     if stat.S_ISDIR(s.st_mode):
         mode = self.dir_perm
     elif stat.S_ISREG(s.st_mode):
         mode = self.file_perm
     return posix.stat_result((mode, ) + s[1:])
Example #3
0
 def getStat(self, file):
     try:
         _time = (file['LastModified'].replace(tzinfo=None) -
                  datetime.datetime.utcfromtimestamp(0)).total_seconds()
         top_level_filename = file['Key'].replace(
             "%s/%s/" % (self.username, self.homeDirectory), "")
         #This an equivalent to 744
         mode = stat.S_IRWXU | stat.S_IRGRP | stat.S_IROTH
         #Stupid hack to detect when a key is a directory instead
         if top_level_filename.endswith('/'):
             top_level_filename = top_level_filename[:-1]
             mode |= stat.S_IFDIR
         else:
             mode |= stat.S_IFREG
         print(
             posix.stat_result(
                 (mode, 0, 0, 1, 0, 0, file['Size'], _time, _time, _time)))
         d = paramiko.SFTPAttributes.from_stat(
             posix.stat_result(
                 (mode, 0, 0, 1, 0, 0, file['Size'], _time, _time, _time)),
             top_level_filename)
         print(d)
         return d
     except Exception as e:
         print(e)
         raise
Example #4
0
  def testFile(self):
    self.mox.StubOutWithMock(os, 'stat')
    os.stat('/home/ebroder/root.img').AndReturn(posix.stat_result([
      0100644, 0, 0, 0, 0, 0, 0, 0, 0, 0]))

    self.mox.ReplayAll()

    self.assertEqual(utils.diskIsBlockDevice('/home/ebroder/root.img'),
                     False)
Example #5
0
  def testBlockDevice(self):
    self.mox.StubOutWithMock(os, 'stat')
    os.stat('/home/ebroder/root.img').AndReturn(posix.stat_result([
      # st_mode is the first argument
      060644, 0, 0, 0, 0, 0, 0, 0, 0, 0]))

    self.mox.ReplayAll()

    self.assertEqual(utils.diskIsBlockDevice('/home/ebroder/root.img'),
                     True)
 def test_constructor_with_opt(self):
     self.assertRaises(TypeError, posix.terminal_size, range(9))
     self.assertRaises(TypeError, posix.terminal_size, range(17))
     x = posix.stat_result(range(10))
     self.assertEqual('os.stat_result(st_mode=0, st_ino=1, st_dev=2, st_nlink=3, st_uid=4, st_gid=5, st_size=6, st_atime=7, st_mtime=8, st_ctime=9)', repr(x))
     x = posix.stat_result(range(16))
     self.assertEqual('os.stat_result(st_mode=0, st_ino=1, st_dev=2, st_nlink=3, st_uid=4, st_gid=5, st_size=6, st_atime=7, st_mtime=8, st_ctime=9)', repr(x))
     x = posix.stat_result(range(10), {'st_atime': 42, 'st_atime_ns': 43, 'abc': 44})
     self.assertEqual(7, x[7])
     self.assertEqual(42, x.st_atime)
     self.assertEqual(43, x.st_atime_ns)
Example #7
0
    def stat(self, path, followlinks=0, path_is_real=False):
        """ Method to access a path state.

        Parameters
        ----------
        path: str (mandatory)
            a path from which we want to get the associated statistics.
        followlinks: int (optional, default 0)
            if True the system will follow the symbolic links with the 'os.stat'
            method,
            otherwise the 'os.lstat' method is used.
        path_is_real: bool (optional, default False)
            if True the path really exists on the file system,
            otherwise we have a virtual cubicweb path.

        Returns
        -------
        out: posix.stat_result
            the same structure returned by a stat or lstat.     
        """
        if not path_is_real:
            virtpath = self.split_virtual_path(path)
            if (virtpath.search_name != '' and
               virtpath.search_name not in (self.all_cw_search_names +
                                            self.INSTANCE_NAMES)):
                # raise OSError like os.stat does
                raise OSError('No such file or directory: "%s"' % path)
            if virtpath.search_relpath == '/' or virtpath.search_relpath == '':
                return posix.stat_result((
                    self.dir_perm,
                    0,  # st_ino
                    0,  # st_dev
                    0,  # st_nlink
                    0,  # st_uid
                    0,  # st_gid
                    4096,  # st_size
                    0,  # st_atime
                    0,  # st_mtime
                    0,  # st_ctime
                ))
            real_path = self.real_path(virtpath)
        else:
            real_path = path
        if followlinks:
            s = os.stat(real_path)
        else:
            s = os.lstat(real_path)
        if stat.S_ISDIR(s.st_mode):
            mode = self.dir_perm
        elif stat.S_ISREG(s.st_mode):
            mode = self.file_perm
        return posix.stat_result((mode,) + s[1:])
 def test_constructor_err(self):
     with self.assertRaisesRegex(TypeError, r'os.terminal_size\(\) takes a dict as second arg, if any'):
         posix.terminal_size((), "")
     self.assertRaises(TypeError, posix.terminal_size)
     with self.assertRaisesRegex(TypeError, r'constructor requires a sequence'):
         posix.terminal_size(42)
     with self.assertRaisesRegex(TypeError, r'os.terminal_size\(\) takes a 2-sequence \(0-sequence given\)'):
         posix.terminal_size(())
     with self.assertRaisesRegex(TypeError, r'os.stat_result\(\) takes an at least 10-sequence \(1-sequence given\)'):
         posix.stat_result((1,))
     with self.assertRaisesRegex(TypeError, r'os.stat_result\(\) takes an at most \d+-sequence \(30-sequence given\)'):
         posix.stat_result((1,) * 30)
     with self.assertRaisesRegex(TypeError, r'cannot create \'sys.flags\' instances'):
         type(sys.flags)()
Example #9
0
    def stat(self):
        if self.path == "":
            return posix.stat_result([stat.S_IFDIR + 0777, 0, 0, 0, 0, 0, 0, 0, 0, 0])
        for data in commands.ls_files(repo=self.repo, index=self.index, path=self.path, children=False):
            if data["path"] == self.path:
                mode = int(data["mode"], 8)
                size = commands.get_object_size(repo=self.repo, object=data["object"])
                return posix.stat_result([mode, 0, 0, 0, 0, 0, size, 0, 0, 0])
            else:
                # if current path has children, it must be a dir
                assert data["path"].startswith(self.path + "/")
                return posix.stat_result([stat.S_IFDIR + 0777, 0, 0, 0, 0, 0, 0, 0, 0, 0])

        # not found
        raise OSError(errno.ENOENT, os.strerror(errno.ENOENT))
Example #10
0
    def stat_file_entity(self, binary_len=0):
        """ Return the file state.

        Parameters
        ----------
        binary_len: int (mandatory)
            the size of the file.

        Returns
        -------
        out: posix.stat_result
            the same structure returned by a stat or lstat.
        """
        return posix.stat_result((
            self.file_perm,
            0,  # st_ino
            0,  # st_dev
            0,  # st_nlink
            0,  # st_uid
            0,  # st_gid
            binary_len,  # st_size
            0,  # st_atime
            0,  # st_mtime
            0,  # st_ctime
        ))
Example #11
0
 def fake_stat(arg):
     if arg in test_filepaths:
         faked = list(orig_os_stat(arg))
         faked[stat.ST_MTIME] = faked[stat.ST_MTIME] + 10
         return stat_result(faked)
     else:
         return orig_os_stat(arg)
 def test_get_device_number(self, lstat):
     lstat.return_value = posix.stat_result([
         16877, 16, 51729L, 3, 0, 0, 217, 0, 1458086872, 1458086872
     ])
     major, minor = replace_osd.get_device_number(1)
     assert major == 202
     assert minor == 17
 def fake_lstat(path):
     st_ino = 0
     st_dev = 0
     if path == ABSTFN:
         st_dev = 1
         st_ino = 1
     return posix.stat_result((0, st_ino, st_dev, 0, 0, 0, 0, 0, 0, 0))
Example #14
0
 def getattr(self, path):
     for backup in self.backups:
         fpath = backup + path
         if os.path.exists(fpath):
             f_stat = os.lstat(fpath)
             mode = f_stat.st_mode
             if S_ISDIR(mode):
                 return f_stat
             else:
                 # it is a file, show as dir
                 f_stat = list(f_stat)
                 f_stat[0] = mode & 0b111111111111 | S_IFDIR
                 f_stat = stat_result(f_stat)
                 assert S_ISDIR(f_stat.st_mode)
                 parent = os.lstat(os.path.dirname(fpath))
                 # print 'done getattr - fake dir'
                 # print 'fstat:  ', f_stat
                 # print 'parent: ', parent
                 return parent  # XXX workaround
                 return f_stat
     # either the path does not exist or it actually is a file
     real_path = self._get_real_path(path)
     # print 'done getattr ', real_path
     if real_path:
         return os.lstat(real_path)
Example #15
0
 def fake_stat(arg):
     if arg == "foo":
         faked = list(orig_os_stat('/tmp'))
         faked[stat.ST_SIZE] = len('some stuff')
         return stat_result(faked)
     else:
         return orig_os_stat(arg)
Example #16
0
    def stat_file_entity(self, binary_len=0):
        """ Return the file state.

        Parameters
        ----------
        binary_len: int (mandatory)
            the size of the file.

        Returns
        -------
        out: posix.stat_result
            the same structure returned by a stat or lstat.
        """
        return posix.stat_result((
            self.file_perm,
            0,  # st_ino
            0,  # st_dev
            0,  # st_nlink
            0,  # st_uid
            0,  # st_gid
            binary_len,  # st_size
            0,  # st_atime
            0,  # st_mtime
            0,  # st_ctime
        ))
Example #17
0
 def getattr(self, path):
     for backup in self.backups:
         fpath = backup + path
         if os.path.exists(fpath):
             f_stat = os.lstat(fpath)
             mode = f_stat.st_mode
             if S_ISDIR(mode):
                 return f_stat
             else:
                 # it is a file, show as dir
                 f_stat = list(f_stat)
                 f_stat[0] = mode & 0b111111111111 | S_IFDIR
                 f_stat = stat_result(f_stat)
                 assert S_ISDIR(f_stat.st_mode)
                 parent = os.lstat(os.path.dirname(fpath))
                 # print 'done getattr - fake dir'
                 # print 'fstat:  ', f_stat
                 # print 'parent: ', parent
                 return parent  # XXX workaround
                 return f_stat
     # either the path does not exist or it actually is a file
     real_path = self._get_real_path(path)
     # print 'done getattr ', real_path
     if real_path:
         return os.lstat(real_path)
Example #18
0
def make_stat(mode=33200, uid=0, gid=0):
    """Return a mocked-up stat.

       The default is:
            mode = 0660
            owner = root
            group = root

       Cheat sheet equivalents:
           0600 = 33152
           0640 = 33184
           0644 = 33188
           0660 = 33200
           0666 = 33206
    """
    # (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)
    return posix.stat_result((
        mode,
        1,
        42,
        1,
        uid,
        gid,
        0,
        1,
        1,
        1,
    ))
Example #19
0
 def fake_lstat(path):
     st_ino = 0
     st_dev = 0
     if path == ABSTFN:
         st_dev = 1
         st_ino = 1
     return posix.stat_result((0, st_ino, st_dev, 0, 0, 0, 0, 0, 0, 0))
Example #20
0
 def fake_stat(arg):
     if arg == '/some/file':  # fake success
         return stat_result((16877, 2, 2049L,
                             23, 0, 0,
                             4096, 1381787843,
                             1381635971, 1381635971))
     else:
         return orig_os_stat(arg)
Example #21
0
 def _os_stat(path):
     if path == working_dir:
         from posix import stat_result
         stat_info = list(real_stat(path))
         stat_info[stat.ST_MODE] |= stat.S_IWOTH
         return stat_result(stat_info)
     else:
         return real_stat(path)
Example #22
0
 def stat(self):
     try:
         return os.stat(self.path)
     except IOError as e:
         with LogLimit(log, 'stat(%s): %s', self.path,
                       limit=LOG_RLIMIT) as ll:
             ll.debug(self.path, e)
         self._reset()
     return posix.stat_result((0, ) * 10)
 def fake_lstat(path):
     st_ino = 0
     st_dev = 0
     if path.startswith(ABSTFN) and path != ABSTFN:
         raise OSError('Fake [Errno 13] Permission denied')
     if path == ABSTFN:
         st_dev = 1
         st_ino = 1
     return posix.stat_result((0, st_ino, st_dev, 0, 0, 0, 0, 0, 0, 0))
Example #24
0
 def getattr(self, path):
     print 'getattr %s' % path
     stats = _get_cache(_ATTR, path)
     if stats is None:
         stats = self._request(self._server.remote_getattr, path)
         _set_cache(_ATTR, path, stats)
     if stats is -1:
         return -errno.ENOENT
     return posix.stat_result(stats)
def make_stat(mode=33200, uid=0, gid=0):
    """Return a mocked-up stat.

       The default is:
            mode = 0660
            owner = root
            group = root
    """
    return posix.stat_result((mode, 1, 42, 1, uid, gid, 0, 1, 1, 1,))
Example #26
0
 def getattr(self, path):
     print '****************************************** getattr %s' % path
     stat = stub.getattr(sankalpa_fs_pb2.Path(path=path), _TIMEOUT_SECONDS)
     if stat.status != 0:
         print '****************************************** getattr status != 0 %s' % stat.status
         raise OSError(stat.status,"OSError", path)
     print '****************************************** server_stat.st_size %s' % stat.st_size
     return posix.stat_result((stat.st_mode, stat.st_ino, stat.st_dev, stat.st_nlink, stat.st_uid, stat.st_gid,
                                                     stat.st_size, stat.st_atime, stat.st_mtime, stat.st_ctime))
 def test_reduce(self):
     x = posix.stat_result(range(10), {'st_atime': 42, 'st_atime_ns': 43, 'abc': 44})
     r = x.__reduce__()
     self.assertEqual(posix.stat_result, r[0])
     self.assertEqual(tuple(range(10)), r[1][0])
     self.assertEqual(42, r[1][1]['st_atime'])
     self.assertEqual(None, r[1][1]['st_mtime_ns'])
     self.assertFalse('abc' in r[1][1])
     x = posix.terminal_size((42, 3.14))
     self.assertEqual((posix.terminal_size, ((42, 3.14), {})), x.__reduce__())
Example #28
0
 def stat(self):
     if not self._stat:
         e = OSError()
         e.errno = errno.ENOENT
         raise e
     if self._file:
         self._stat[6] = self._file.len
     ## bloat ... turning a list to a sequence to a stat_result object ;-)
     ## Well, StringIO implementation is not quite optimal anyway ;-)
     return posix.stat_result(list(self._stat))
Example #29
0
 def dispatch(me):
     stat_res = me._dispatch()
     #if os.path.split( me.q.path_in_aspect)[0] and isinstance( stat_res, stat_result):
     if Hardlink.getattr4symlink and isinstance(stat_res, stat_result):
         all = list(stat_res)
         log('original:', all)
         all[0] = all[0] | S_IFLNK
         log('new:', all)
         stat_res = stat_result(all)
     Hardlink.getattr4symlink = False
     return stat_res
Example #30
0
 def fake_lstat(path):
     st_ino = 0
     st_dev = 0
     if path.startswith(ABSTFN) and path != ABSTFN:
         # ismount tries to read something inside the ABSTFN directory;
         # simulate this being forbidden (no read permission).
         raise OSError("Fake [Errno 13] Permission denied")
     if path == ABSTFN:
         st_dev = 1
         st_ino = 1
     return posix.stat_result((0, st_ino, st_dev, 0, 0, 0, 0, 0, 0, 0))
Example #31
0
 def dispatch(me):
     stat_res = me._dispatch()
     # if os.path.split( me.q.path_in_aspect)[0] and isinstance( stat_res, stat_result):
     if Hardlink.getattr4symlink and isinstance(stat_res, stat_result):
         all = list(stat_res)
         log("original:", all)
         all[0] = all[0] | S_IFLNK
         log("new:", all)
         stat_res = stat_result(all)
     Hardlink.getattr4symlink = False
     return stat_res
Example #32
0
 def fake_lstat(path):
     st_ino = 0
     st_dev = 0
     if path.startswith(ABSTFN) and path != ABSTFN:
         # ismount tries to read something inside the ABSTFN directory;
         # simulate this being forbidden (no read permission).
         raise OSError("Fake [Errno 13] Permission denied")
     if path == ABSTFN:
         st_dev = 1
         st_ino = 1
     return posix.stat_result((0, st_ino, st_dev, 0, 0, 0, 0, 0, 0, 0))
Example #33
0
 def myLstat(path):
     s = origLstat(path)
     if path == fobj.name:
         # Convert the stat info to a tuple
         s = tuple(s)
         # Replace st_uid and st_gid
         s = s[:4] + (uid, gid) + s[6:]
         # Convert to stat_result
         s = posix.stat_result(s)
         self.assertEqual(s.st_uid, uid)
         self.assertEqual(s.st_gid, gid)
     return s
 def stat_file_entity(self, binary_len=0):
     return posix.stat_result((
         self.file_perm,
         0,  # st_ino
         0,  # st_dev
         0,  # st_nlink
         0,  # st_uid
         0,  # st_gid
         binary_len,  # st_size
         0,  # st_atime
         0,  # st_mtime
         0,  # st_ctime
     ))
Example #35
0
    def fgetattr(self, file_descriptor, path):
        logging.debug('FGETATTR')

        try:
            op_result = os.fstat(file_descriptor)
            file_size = self.file_table[path + 'size']
            stats_list = list(op_result)
            stats_list[stat.ST_SIZE] = file_size
            op_result = posix.stat_result(stats_list)
        except:
            op_result = -errno.EACCES

        return op_result
Example #36
0
 def stat_file_entity(self, binary_len=0):
     return posix.stat_result((
         self.file_perm,
         0,  # st_ino
         0,  # st_dev
         0,  # st_nlink
         0,  # st_uid
         0,  # st_gid
         binary_len,  # st_size
         0,  # st_atime
         0,  # st_mtime
         0,  # st_ctime
     ))
Example #37
0
 def fgetattr( self, file_descriptor, path ):
     logging.debug( 'FGETATTR' )
     
     try:
         op_result = os.fstat( file_descriptor )
         file_size = self.file_table[ path + 'size' ]
         stats_list = list( op_result )
         stats_list[ stat.ST_SIZE ] = file_size
         op_result = posix.stat_result( stats_list )
     except:
         op_result = -errno.EACCES
     
     return op_result
Example #38
0
 def getattr( self, path ):
     logging.debug( 'GETATTR' )
 
     try:
         op_result = os.lstat( self.root + path[1:] )
         if path in self.file_table.keys():
             file_size = self.file_table[ path + 'size' ]
             stats_list = list( op_result )
             stats_list[ stat.ST_SIZE ] = file_size
             op_result = posix.stat_result( stats_list )
     except:
         op_result = -errno.ENOENT
         
     return op_result
Example #39
0
    def getattr(self, path):
        logging.debug('GETATTR')

        try:
            op_result = os.lstat(self.root + path[1:])
            if path in self.file_table.keys():
                file_size = self.file_table[path + 'size']
                stats_list = list(op_result)
                stats_list[stat.ST_SIZE] = file_size
                op_result = posix.stat_result(stats_list)
        except:
            op_result = -errno.ENOENT

        return op_result
Example #40
0
 def stat(self, path):
     """Return stat result."""
     local_path = self.resolve(path)
     cmd = 'stat --printf="%f %i %d %h %u %g %s %X %Y %W" {path}' \
           .format(path=local_path)
     result = self.xal_session.sh.run(cmd)
     if not result.succeeded:
         if not self.exists(path):
             raise OSError(path)
         raise Exception()
     result = result.stdout.split(" ")
     result[0] = int(result[0], base=16)
     result = map(int, result)
     return posix.stat_result(result)
Example #41
0
    def stat(self, path):
        """
        Returns ``os.stat(path)`` if `path` is legal.

        path: string
            Path to file to interrogate.
        """
        timeout = 5 * 60
        info = self._conn.invoke('stat', (path,), timeout=timeout)
        if sys.platform == 'win32':  # pragma no cover
            import nt
            return nt.stat_result(info)
        else:
            import posix
            return posix.stat_result(info)
Example #42
0
 def test_simple(self):
     st = posix.stat_result((16877, 131078, 64769L,
             154, 1000, 1000, 12288,
             1323629595, 1324180496, 1324180496))
     entry = index_entry_from_stat(st, "22" * 20, 0)
     self.assertEquals(entry, (
         1324180496,
         1324180496,
         64769L,
         131078,
         16877,
         1000,
         1000,
         12288,
         '2222222222222222222222222222222222222222',
         0))
Example #43
0
    def fake_stat(file: str):
        """
        Create a real stat_result using an actual file, but change the st_mtime
        to a known value before returning it.

        Args:
            file: filename (not used)

        Returns:
            mocked stat_results
        """
        s = os.stat(".")
        t = int(datetime.datetime(2021, 1, 29, 0, 0, 0).timestamp())
        f = list(s)
        f[ST_MTIME] = t
        return stat_result(f)
Example #44
0
    def set_stat_info(self, value):
        """Sets the file stat information.  Takes multiple parameter types:

        @param {tuple|list|stat_result|unicode|str} value
        """
        if value is None:
            value = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

        if isinstance(value, tuple) or isinstance(value, list):
            value = os_platform.stat_result(tuple(value))
            self._dict['statInfo'] = value
            self._dict['description'] = \
                b64encode(compress(pickle.dumps(value)))

            return

        if isinstance(value, os_platform.stat_result):
            try:
                self._dict['description'] = \
                    b64encode(compress(pickle.dumps(value)))
                self._dict['statInfo'] = value
            except pickle.PicklingError:
                pass

            return

        if isinstance(value, unicode):
            value = unicode(value).encode("utf8")

        if isinstance(value, str):
            # First decode using new base64 compressed method.
            try:
                self._dict['statInfo'] = \
                    pickle.loads(decompress(b64decode(value)))
                self._dict['description'] = value
                return
            except Exception, ex:
                debug("Base 64 decode failed: %s" % repr(ex))

            # That failed, try to decode using old hex encoding.
            try:
                dvalue = str(value).decode("hex")
                self._dict['statInfo'] = pickle.loads(dvalue)
                self._dict['description'] = value
                return
            except Exception, ex:
                debug("Hex decode failed: %s" % repr(ex))
Example #45
0
    def set_stat_info(self, value):
        """Sets the file stat information.  Takes multiple parameter types:

        @param {tuple|list|stat_result|unicode|str} value
        """
        if value is None:
            value = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

        if isinstance(value, tuple) or isinstance(value, list):
            value = os_platform.stat_result(tuple(value))
            self._dict['statInfo'] = value
            self._dict['description'] = \
                b64encode(compress(pickle.dumps(value)))

            return

        if isinstance(value, os_platform.stat_result):
            try:
                self._dict['description'] = \
                    b64encode(compress(pickle.dumps(value)))
                self._dict['statInfo'] = value
            except pickle.PicklingError:
                pass

            return

        if isinstance(value, unicode):
            value = unicode(value).encode("utf8")

        if isinstance(value, str):
            # First decode using new base64 compressed method.
            try:
                self._dict['statInfo'] = \
                    pickle.loads(decompress(b64decode(value)))
                self._dict['description'] = value
                return
            except Exception, ex:
                debug("Base 64 decode failed: %s" % repr(ex))

            # That failed, try to decode using old hex encoding.
            try:
                dvalue = str(value).decode("hex")
                self._dict['statInfo'] = pickle.loads(dvalue)
                self._dict['description'] = value
                return
            except Exception, ex:
                debug("Hex decode failed: %s" % repr(ex))
Example #46
0
    def _setStatInfo(self, value):
        if value is None:
            value = (0,0,0,0,0,0,0,0,0,0)

        if isinstance(value, tuple) or isinstance(value, list):
            value = posix.stat_result(tuple(value))
            self._dict['statInfo'] = value
            self._dict['description'] = \
                b64encode(compress(pickle.dumps(value))) 

            return
            
        if isinstance(value, posix.stat_result):
            try:
                self._dict['description'] = \
                    b64encode(compress(pickle.dumps(value))) 
                self._dict['statInfo'] = value
            except pickle.PicklingError:
                pass

            return

        if isinstance(value, unicode):
            value = value.encode("utf8")

        if isinstance(value, str):
            # First decode using new base64 compressed method.
            try:
                self._dict['statInfo'] = \
                    pickle.loads(decompress(b64decode(value)))
                self._dict['description'] = value
                return
            except Exception, e:
                debug("Base 64 decode failed: %s" % repr(e))
                pass

            # That failed, try to decode using old hex encoding.
            try:
                self._dict['statInfo'] = pickle.loads(value.decode("hex"))
                self._dict['description'] = value
                return
            except Exception, e:
                debug("Hex decode failed: %s" % repr(e))
                pass
Example #47
0
    def _setStatInfo(self, value):
        if value is None:
            value = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

        if isinstance(value, tuple) or isinstance(value, list):
            value = posix.stat_result(tuple(value))
            self._dict['statInfo'] = value
            self._dict['description'] = \
                b64encode(compress(pickle.dumps(value)))

            return

        if isinstance(value, posix.stat_result):
            try:
                self._dict['description'] = \
                    b64encode(compress(pickle.dumps(value)))
                self._dict['statInfo'] = value
            except pickle.PicklingError:
                pass

            return

        if isinstance(value, unicode):
            value = value.encode("utf8")

        if isinstance(value, str):
            # First decode using new base64 compressed method.
            try:
                self._dict['statInfo'] = \
                    pickle.loads(decompress(b64decode(value)))
                self._dict['description'] = value
                return
            except Exception, e:
                debug("Base 64 decode failed: %s" % repr(e))
                pass

            # That failed, try to decode using old hex encoding.
            try:
                self._dict['statInfo'] = pickle.loads(value.decode("hex"))
                self._dict['description'] = value
                return
            except Exception, e:
                debug("Hex decode failed: %s" % repr(e))
                pass
Example #48
0
    def _setStatInfo(self, value):
        if value is None:
            value = (0,0,0,0,0,0,0,0,0,0)

        if isinstance(value, tuple) or isinstance(value, list):
            value = posix.stat_result(tuple(value))
            self._dict['statInfo'] = value
            self._dict['description'] = pickle.dumps(
                value
            ).encode("hex")

            return
            
        if isinstance(value, posix.stat_result):
            try:
                self._dict['description'] = pickle.dumps(
                    value
                ).encode("hex")
                self._dict['statInfo'] = value
            except pickle.PicklingError:
                pass

            return

        if isinstance(value, unicode):
            value = str(value)

        if isinstance(value, str):
            try:
                self._dict['statInfo'] = pickle.loads(
                    value.decode("hex")
                )
                self._dict['description'] = value
            except pickle.UnpicklingError:
                pass
            except EOFError:
                pass

            return

        raise EInvalidStatInfoType(type(value))
Example #49
0
def make_stat(mode=33200, uid=0, gid=0):
    """Return a mocked-up stat.

       The default is:
            mode = 0660
            owner = root
            group = root
    """
    # (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)
    return posix.stat_result((
        mode,
        1,
        42,
        1,
        uid,
        gid,
        0,
        1,
        1,
        1,
    ))
Example #50
0
def PyStructSequence_New(typ):
    return stat_result([None] * stat_result.n_sequence_fields * 2)
Example #51
0
 def fake_lstat(*args, **kwargs):
     #posix.lstat_result(st_mode=1, st_ino=2, st_dev=3, st_nlink=4,
     #                   st_uid=5, st_gid=6, st_size=7, st_atime=8,
     #                   st_mtime=9, st_ctime=10)
     return stat_result((1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
Example #52
0
 def fake_lstat(self, *args, **kwargs):
     self.lstat_calls.append((args, kwargs))
     return stat_result(self.lstat_output_tuple)
Example #53
0
def fake_stat_illegal(path):
    # Simulate stat to return the mode of a block device
    # make sure that st_mode (the first in the sequence(
    # matches the mode of a block device
    return posix.stat_result((17407, 5753, 5L, 1, 0, 6, 0,
                              1375881199, 1375881197, 1375881197))
Example #54
0
 def _stat_request_hadler(chunk):
     return func(posix.stat_result(msgpack.unpackb(chunk)))
Example #55
0
 def _stat_request_hadler(chunk):
     return func(posix.stat_result(msgpack.unpackb(chunk)))
Example #56
0
def PyStructSequence_New(typ):
    from posix import stat_result
    return stat_result([None] * stat_result.n_sequence_fields * 2)
Example #57
0
def fake_stat_illegal(path):
    # Simulate stat to return the mode of a block device
    # make sure that st_mode (the first in the sequence(
    # matches the mode of a block device
    return posix.stat_result(
        (17407, 5753, 5, 1, 0, 6, 0, 1375881199, 1375881197, 1375881197))