Example #1
0
File: os_path.py Project: bsa3/oil
def exists(path):
    """Test whether a path exists.  Returns False for broken symbolic links"""
    try:
        posix.stat(path)
    except posix.error:
        return False
    return True
Example #2
0
 def test_stat_unicode(self):
     # test that passing unicode would not raise UnicodeDecodeError
     import posix
     try:
         posix.stat(u"ą")
     except OSError:
         pass
Example #3
0
 def exists(path):
     """Local re-implementation of os.path.exists."""
     try:
         stat(path)
     except EnvironmentError:
         return False
     return True
Example #4
0
 def test_stat_unicode(self):
     # test that passing unicode would not raise UnicodeDecodeError
     import posix
     try:
         posix.stat(u"ą")
     except OSError:
         pass
Example #5
0
def dir_exists(f):
    try:
        posix.stat(f)
        return 1
    except posix.error, (a, b):
        if (a != 2):
            raise sys.exc_type, sys.exc_value, sys.exc_traceback
        return 0
Example #6
0
def exists(path):
    """Local re-implementation of os.path.exists."""
    try:
        stat(path)
    except EnvironmentError, e:
        # TODO: how to get the errno under RPython?
        if not __rpython__:
            if e.errno not in (errno.ENOENT, errno.ENOTDIR, errno.ESRCH):
                raise
        return False
Example #7
0
def cmp(f1, f2): # Compare two files, use the cache if possible.
       # Return 1 for identical files, 0 for different.
       # Raise exceptions if either file could not be statted, read, etc.
       s1, s2 = sig(posix.stat(f1)), sig(posix.stat(f2))
       if s1[0] <> 8 or s2[0] <> 8:
               # Either is a not a plain file -- always report as different
               return 0
       if s1 = s2:
               # type, size & mtime match -- report same
               return 1
Example #8
0
def exists(path):
    """Local re-implementation of os.path.exists."""
    try:
        stat(path)
    except EnvironmentError, e:
        # TODO: how to get the errno under RPython?
        if not __rpython__:
            if e.errno not in (errno.ENOENT,errno.ENOTDIR,errno.ESRCH,):
                raise
        return False
Example #9
0
def exists(path):
    """Local re-implementation of os.path.exists."""
    try:
        stat(path)
    except EnvironmentError:
        e = sys.exc_info()[1]
        if e.errno not in (errno.ENOENT,errno.ENOTDIR,errno.ESRCH,):
            raise
        else:
            return False
    else:
        return True
Example #10
0
def ismount(path):
    try:
        s1 = posix.stat(path)
        s2 = posix.stat(join(path, '..'))
    except posix.error:
        return 0  # It doesn't exist -- so not a mount point :-)
    dev1 = s1[stat.ST_DEV]
    dev2 = s2[stat.ST_DEV]
    if dev1 != dev2:
        return 1  # path/.. on a different device as path
    ino1 = s1[stat.ST_INO]
    ino2 = s2[stat.ST_INO]
    if ino1 == ino2:
        return 1  # path/.. is the same i-node as path
    return 0
Example #11
0
def ismount(path):
	try:
		s1 = posix.stat(path)
		s2 = posix.stat(join(path, '..'))
	except posix.error:
		return 0 # It doesn't exist -- so not a mount point :-)
	dev1 = s1[stat.ST_DEV]
	dev2 = s2[stat.ST_DEV]
	if dev1 != dev2:
		return 1		# path/.. on a different device as path
	ino1 = s1[stat.ST_INO]
	ino2 = s2[stat.ST_INO]
	if ino1 == ino2:
		return 1		# path/.. is the same i-node as path
	return 0
Example #12
0
File: os_path.py Project: bsa3/oil
def isdir(s):
    """Return true if the pathname refers to an existing directory."""
    try:
        st = posix.stat(s)
    except posix.error:
        return False
    return stat.S_ISDIR(st.st_mode)
Example #13
0
def which(program):
    """Like /bin/csh's which command.

    Takes a program name as an argument, and searches the PATH
    environment variable for the specified program.  If found, the
    full path to program is returned, otherwise None is returned."""
    # first figure out which PATH we're going to search
    try:
        path = os.environ['PATH']
    except KeyError:
        path = os.defpath

    # split the path
    import string
    import posix
    import stat
    pathdirs = string.splitfields(path, os.pathsep)

    found_p = None
    for dir in pathdirs:
        try:
            found_p = os.path.join(dir, program)
            st = posix.stat(found_p)
            # check for both a regular file, and executable by owner
            if not stat.S_ISREG(st[stat.ST_MODE]) or \
               not (stat.S_IMODE(st[stat.ST_MODE]) & stat.S_IXUSR):
                # nope
                found_p = None
        except posix.error:
            found_p = None

        # if a path was found, we're done
        if found_p: return found_p
    # never found
    return None
Example #14
0
def files(request, publication_id):

  publication = get_object_or_404(Publication, pk=publication_id)
  filepath = publication.file.__unicode__()

  name, ext = splitext(filepath)

  filepath_absolute = join(settings.MEDIA_ROOT, filepath)

  if not exists(filepath_absolute):
    raise Http404

  statinfo = stat(filepath_absolute)

  mimetype = mimetypes.guess_type(filepath_absolute)

  mode = getattr(settings, 'PUBLICATIONS_DOWNLOAD_MODE', '')
  if mode == 'apache':
    response = HttpResponse(content_type=mimetype)
    response['X-Sendfile'] = smart_str(filepath_absolute)
  if mode == 'nginx':
    response = HttpResponse(content_type=mimetype)
    response['X-Accel-Redirect'] = smart_str(settings.MEDIA_URL + filepath)
  else:
    response = HttpResponse(open(filepath_absolute, "r"), content_type=mimetype)

  response['Content-Length'] = statinfo.st_size
  response['Content-Disposition'] = 'attachment; filename=%s%s' % (smart_str(publication.generate_identifier()), ext)
  response['Cache-Control'] = 'no-cache, must-revalidate'

  return response
Example #15
0
    def Matches(self, comp):
        """
    TODO: Cache is never cleared.

    - When we get a newer timestamp, we should clear the old one.
    - When PATH is changed, we can remove old entries.
    """
        val = self.mem.GetVar('PATH')
        if val.tag != value_e.Str:
            # No matches if not a string
            return
        path_dirs = val.s.split(':')
        #print(path_dirs)

        names = []
        for d in path_dirs:
            try:
                st = posix.stat(d)
            except OSError as e:
                # There could be a directory that doesn't exist in the $PATH.
                continue
            key = (d, st.st_mtime)
            listing = self.cache.get(key)
            if listing is None:
                listing = posix.listdir(d)
                self.cache[key] = listing
            names.extend(listing)

        # TODO: Shouldn't do the prefix / space thing ourselves.  readline does
        # that at the END of the line.
        for word in listing:
            if word.startswith(comp.to_complete):
                yield word + ' '
Example #16
0
 def test_posix_stat_result(self):
     try:
         import posix
     except ImportError:
         return
     expect = posix.stat(__file__)
     encoded = jsonpickle.encode(expect)
     actual = jsonpickle.decode(encoded)
     self.assertEqual(expect, actual)
Example #17
0
 def test_posix_stat_result(self):
     try:
         import posix
     except ImportError:
         return
     expect = posix.stat(__file__)
     encoded = jsonpickle.encode(expect)
     actual = jsonpickle.decode(encoded)
     self.assertEqual(expect, actual)
Example #18
0
def readable(path):
    try:
        mode = posix.stat(path)[stat.ST_MODE]
    except OSError:               # File doesn't exist
        sys.stderr.write("%s not found\n"%path)
        sys.exit(1)
    if not stat.S_ISREG(mode):    # or it's not readable
        sys.stderr.write("%s not readable\n"%path)
        sys.exit(1)
Example #19
0
def test_posix_stat_result():
    """Serialize a posix.stat() result"""
    try:
        import posix
    except ImportError:
        return
    expect = posix.stat(__file__)
    encoded = jsonpickle.encode(expect)
    actual = jsonpickle.decode(encoded)
    assert expect == actual
Example #20
0
def skipfile(file):
       if file in badnames or \
               badprefix(file) or badsuffix(file) or \
               path.islink(file) or path.isdir(file):
               return 1
       # Skip huge files -- probably binaries.
       try:
               st = posix.stat(file)
       except posix.error:
               return 1 # Doesn't exist -- skip it
       return st[stat.ST_SIZE] >= MAXSIZE
Example #21
0
def readfile(fn):
	st = posix.stat(fn)
	size = st[stat.ST_SIZE]
	if not size: return ''
	try:
		fp = open(fn, 'r')
	except:
		raise posix.error, 'readfile(' + fn + '): open failed'
	try:
		return fp.read(size)
	except:
		raise posix.error, 'readfile(' + fn + '): read failed'
Example #22
0
def mkrealdir(name):
       st = posix.stat(name) # Get the mode
       mode = S_IMODE(st[ST_MODE])
       linkto = posix.readlink(name)
       files = posix.listdir(name)
       posix.unlink(name)
       posix.mkdir(name, mode)
       posix.chmod(name, mode)
       linkto = cat('..', linkto)
       #
       for file in files:
               if file not in ('.', '..'):
                       posix.symlink(cat(linkto, file), cat(name, file))
Example #23
0
def mkrealfile(name):
    st = posix.stat(name)  # Get the mode
    mode = S_IMODE(st[ST_MODE])
    linkto = posix.readlink(name)  # Make sure again it's a symlink
    f_in = open(name, 'r')  # This ensures it's a file
    posix.unlink(name)
    f_out = open(name, 'w')
    while 1:
        buf = f_in.read(BUFSIZE)
        if not buf: break
        f_out.write(buf)
    del f_out  # Flush data to disk before changing mode
    posix.chmod(name, mode)
Example #24
0
def mkrealfile(name):
       st = posix.stat(name) # Get the mode
       mode = S_IMODE(st[ST_MODE])
       linkto = posix.readlink(name) # Make sure again it's a symlink
       f_in = open(name, 'r') # This ensures it's a file
       posix.unlink(name)
       f_out = open(name, 'w')
       while 1:
               buf = f_in.read(BUFSIZE)
               if not buf: break
               f_out.write(buf)
       del f_out # Flush data to disk before changing mode
       posix.chmod(name, mode)
Example #25
0
def mkrealdir(name):
    st = posix.stat(name)  # Get the mode
    mode = S_IMODE(st[ST_MODE])
    linkto = posix.readlink(name)
    files = posix.listdir(name)
    posix.unlink(name)
    posix.mkdir(name, mode)
    posix.chmod(name, mode)
    linkto = cat('..', linkto)
    #
    for file in files:
        if file not in ('.', '..'):
            posix.symlink(cat(linkto, file), cat(name, file))
def tun_tap_available(tap_only=0, probe_only=0):
    if sys.platform[:5] == "sunos":
        if tap_only:
            msg = "Solaris does not support TAP, only TUN."
            return tun_tap_error(msg, 0, probe_only)
        # TODO:
        msg = "No TUN support for Solaris yet."
        return tun_tap_error(msg, 0, probe_only)
    elif sys.platform[:5] == "linux":
        device_name = "/dev/net/tun"
    else:
        # TODO: actually check if the TAP driver is installed
        return 1
        # msg = "Simics does not support TUN/TAP on %s." % sys.platform
        # return tun_tap_error(msg, 0, probe_only)

    try:
        posix.stat(device_name)
        have_tun = 1
        try:
            fd = open(device_name, "rw")
            fd.close()
            tun_ok = 1
        except:
            tun_ok = 0
    except:
        have_tun = 0

    if have_tun == 0:
        msg = "TUN/TAP not supported on this host. (No %s found)." % device_name
        return tun_tap_error(msg, 1, probe_only)
    elif tun_ok == 0:
        msg = ("TUN/TAP device not accessible. (Check permissions of the " +
               "%s device file.)" % device_name)
        return tun_tap_error(msg, 1, probe_only)
    return 1
Example #27
0
def listdir(path):  # List directory contents, using cache
    try:
        cached_mtime, list = cache[path]
        del cache[path]
    except RuntimeError:
        cached_mtime, list = -1, []
    try:
        mtime = posix.stat(path)[8]
    except posix.error:
        return []
    if mtime <> cached_mtime:
        try:
            list = posix.listdir(path)
        except posix.error:
            return []
        list.sort()
    cache[path] = mtime, list
    return list
Example #28
0
def listdir(path):  # List directory contents, using cache
    try:
        cached_mtime, list = cache[path]
        del cache[path]
    except RuntimeError:
        cached_mtime, list = -1, []
    try:
        mtime = posix.stat(path)[8]
    except posix.error:
        return []
    if mtime <> cached_mtime:
        try:
            list = posix.listdir(path)
        except posix.error:
            return []
        list.sort()
    cache[path] = mtime, list
    return list
Example #29
0
    def Matches(self, comp):
        """
    TODO: Cache is never cleared.

    - When we get a newer timestamp, we should clear the old one.
    - When PATH is changed, we can remove old entries.
    """
        val = self.mem.GetVar('PATH')
        if val.tag != value_e.Str:
            # No matches if not a string
            return
        path_dirs = val.s.split(':')
        #log('path: %s', path_dirs)

        executables = []
        for d in path_dirs:
            try:
                st = posix.stat(d)
            except OSError as e:
                # There could be a directory that doesn't exist in the $PATH.
                continue
            key = (d, st.st_mtime)

            dir_exes = self.cache.get(key)
            if dir_exes is None:
                entries = posix.listdir(d)
                dir_exes = []
                for name in entries:
                    path = os_path.join(d, name)
                    # TODO: Handle exception if file gets deleted in between listing and
                    # check?
                    if not posix.access(path, posix.X_OK):
                        continue
                    dir_exes.append(name)  # append the name, not the path

                self.cache[key] = dir_exes

            executables.extend(dir_exes)

        # TODO: Shouldn't do the prefix / space thing ourselves.  readline does
        # that at the END of the line.
        for word in executables:
            if word.startswith(comp.to_complete):
                yield word
Example #30
0
import posix

mask = 0o170000
mask2 = 0o777
S_IFDIR = 0o40000
S_IFREG = 0o100000
S_IFLNK = 0o120000

sr = posix.stat("programs/files/stat")
assert sr.st_mode & mask == S_IFREG
assert sr.st_mode & mask2 == 0o664
assert sr.st_dev == 0x815
assert sr.st_ino.__class__ is int
assert sr.st_nlink.__class__ is int
assert sr.st_uid == 1003
assert sr.st_gid == 1003
assert sr.st_size == 4
assert int(sr.st_atime) >= 1372977779, sr.st_atime
assert int(sr.st_mtime) >= 1366755120, sr.st_mtime
assert sr.st_ctime.__class__ is float

sr2 = posix.stat("programs/files/stat2")
assert sr2.st_mode & mask == S_IFDIR

sr3 = posix.stat("programs/files/stat3", follow_symlinks=False)
assert sr3.st_mode & mask == S_IFLNK
sr3 = posix.stat("programs/files/stat3")
assert sr3.st_mode & mask == S_IFDIR
Example #31
0
import posix
import errno

try:
  posix.stat("programs/files/filenotfound")
except FileNotFoundError as e:
  assert e.errno == errno.ENOENT
  try:
    posix.stat("programs/files/stat4/somefile")
  except PermissionError as e:
    assert e.errno == errno.EACCES
    try:
      posix.stat("programs/files/stat/somefile")
    except NotADirectoryError as e:
      assert e.errno == errno.ENOTDIR
      try:
        posix.stat("programs/files/" + "stat3/" * 100)
      except OSError as e:
        assert e.__class__ is OSError
        assert e.errno == errno.ELOOP
        try:
          posix.stat("programs/files/" * 1000)
        except OSError as e:
          assert e.__class__ is OSError
          assert e.errno == errno.ENAMETOOLONG
          x = 5

assert x == 5
Example #32
0
def isdir(path):
	try:
		st = posix.stat(path)
	except posix.error:
		return 0
	return stat.S_ISDIR(st[stat.ST_MODE])
Example #33
0
def exists(path):
	try:
		st = posix.stat(path)
	except posix.error:
		return 0
	return 1
Example #34
0
def isfile(path):
    try:
        st = posix.stat(path)
    except posix.error:
        return 0
    return stat.S_ISREG(st[stat.ST_MODE])
Example #35
0
 def do_stat(self, path):
     if not path:
         path = self._work_dir
     print posix.stat(path)
Example #36
0
import sys
import rpyc
from plumbum import SshMachine
from rpyc.utils.zerodeploy import DeployedServer
from rpyc.utils.splitbrain import splitbrain

mach = SshMachine("192.168.1.117")

print sys.platform

with DeployedServer(mach) as dep:
    conn = dep.classic_connect()
    print conn.modules.sys.platform
    
    try:
        import posix
    except ImportError as ex:
        print ex
    
    with splitbrain(conn):
        import posix
        print posix.stat("/boot")

    print posix



Example #37
0
def samefile(f1, f2):
	s1 = posix.stat(f1)
	s2 = posix.stat(f2)
	return samestat(s1, s2)
Example #38
0
def isfile(path):
	try:
		st = posix.stat(path)
	except posix.error:
		return 0
	return stat.S_ISREG(st[stat.ST_MODE])
Example #39
0
def isdir(path):
	try:
		st = posix.stat(path)
	except posix.error:
		return 0
	return stat.S_ISDIR(st[stat.ST_MODE])
Example #40
0
def exists(path):
	try:
		st = posix.stat(path)
	except posix.error:
		return 0
	return 1
Example #41
0
def copystat(src, dst):
       st = posix.stat(src)
       mode = divmod(st[0], MODEBITS)[1]
       posix.chmod(dst, mode)
       posix.utimes(dst, st[7:9])
Example #42
0
  def Eval(self, node):
    #print('!!', node.tag)

    if node.tag == bool_expr_e.WordTest:
      s = self._EvalCompoundWord(node.w)
      return bool(s)

    if node.tag == bool_expr_e.LogicalNot:
      b = self.Eval(node.child)
      return not b

    if node.tag == bool_expr_e.LogicalAnd:
      # Short-circuit evaluation
      if self.Eval(node.left):
        return self.Eval(node.right)
      else:
        return False

    if node.tag == bool_expr_e.LogicalOr:
      if self.Eval(node.left):
        return True
      else:
        return self.Eval(node.right)

    if node.tag == bool_expr_e.BoolUnary:
      op_id = node.op_id
      s = self._EvalCompoundWord(node.child)

      # Now dispatch on arg type
      arg_type = BOOL_ARG_TYPES[op_id]  # could be static in the LST?

      if arg_type == bool_arg_type_e.Path:
        # Only use lstat if we're testing for a symlink.
        if op_id in (Id.BoolUnary_h, Id.BoolUnary_L):
          try:
            mode = posix.lstat(s).st_mode
          except OSError:
            return False

          return stat.S_ISLNK(mode)

        try:
          mode = posix.stat(s).st_mode
        except OSError:
          # TODO: Signal extra debug information?
          #log("Error from stat(%r): %s" % (s, e))
          return False

        if op_id in (Id.BoolUnary_e, Id.BoolUnary_a):  # -a is alias for -e
          return True

        if op_id == Id.BoolUnary_f:
          return stat.S_ISREG(mode)

        if op_id == Id.BoolUnary_d:
          return stat.S_ISDIR(mode)

        if op_id == Id.BoolUnary_x:
          return posix.access(s, posix.X_OK)

        if op_id == Id.BoolUnary_r:
          return posix.access(s, posix.R_OK)

        if op_id == Id.BoolUnary_w:
          return posix.access(s, posix.W_OK)

        raise NotImplementedError(op_id)

      if arg_type == bool_arg_type_e.Str:
        if op_id == Id.BoolUnary_z:
          return not bool(s)
        if op_id == Id.BoolUnary_n:
          return bool(s)

        raise NotImplementedError(op_id)

      if arg_type == bool_arg_type_e.Other:
        if op_id == Id.BoolUnary_t:
          try:
            fd = int(s)
          except ValueError:
            # TODO: Need location information of [
            e_die('Invalid file descriptor %r', s)
          return posix.isatty(fd)

        raise NotImplementedError(op_id)

      raise NotImplementedError(arg_type)

    if node.tag == bool_expr_e.BoolBinary:
      op_id = node.op_id

      s1 = self._EvalCompoundWord(node.left)
      # Whether to glob escape
      do_fnmatch = op_id in (Id.BoolBinary_GlobEqual, Id.BoolBinary_GlobDEqual,
                             Id.BoolBinary_GlobNEqual)
      do_ere = (op_id == Id.BoolBinary_EqualTilde)
      s2 = self._EvalCompoundWord(node.right, do_fnmatch=do_fnmatch,
                                  do_ere=do_ere)

      # Now dispatch on arg type
      arg_type = BOOL_ARG_TYPES[op_id]

      if arg_type == bool_arg_type_e.Path:
        st1 = posix.stat(s1)
        st2 = posix.stat(s2)

        # TODO: test newer than (mtime)
        if op_id == Id.BoolBinary_nt:
          return st1[stat.ST_MTIME] > st2[stat.ST_MTIME]
        if op_id == Id.BoolBinary_ot:
          return st1[stat.ST_MTIME] < st2[stat.ST_MTIME]

        raise NotImplementedError(op_id)

      if arg_type == bool_arg_type_e.Int:
        # NOTE: We assume they are constants like [[ 3 -eq 3 ]].
        # Bash also allows [[ 1+2 -eq 3 ]].
        i1 = self._StringToIntegerOrError(s1, blame_word=node.left)
        i2 = self._StringToIntegerOrError(s2, blame_word=node.right)

        if op_id == Id.BoolBinary_eq:
          return i1 == i2
        if op_id == Id.BoolBinary_ne:
          return i1 != i2
        if op_id == Id.BoolBinary_gt:
          return i1 > i2
        if op_id == Id.BoolBinary_ge:
          return i1 >= i2
        if op_id == Id.BoolBinary_lt:
          return i1 < i2
        if op_id == Id.BoolBinary_le:
          return i1 <= i2

        raise NotImplementedError(op_id)

      if arg_type == bool_arg_type_e.Str:

        if op_id in (Id.BoolBinary_GlobEqual, Id.BoolBinary_GlobDEqual):
          #log('Matching %s against pattern %s', s1, s2)

          # TODO: Respect extended glob?  * and ! and ? are quoted improperly.
          # But @ and + are OK.
          return libc.fnmatch(s2, s1)

        if op_id == Id.BoolBinary_GlobNEqual:
          return not libc.fnmatch(s2, s1)

        if op_id in (Id.BoolBinary_Equal, Id.BoolBinary_DEqual):
          return s1 == s2

        if op_id == Id.BoolBinary_NEqual:
          return s1 != s2

        if op_id == Id.BoolBinary_EqualTilde:
          #log('Matching %r against regex %r', s1, s2)
          try:
            matches = libc.regex_match(s2, s1)
          except RuntimeError:
            # 2 means a parse error.  Note this is a fatal error in OSH but not
            # in bash.
            e_die("Invalid regex %r", s2, word=node.right, status=2)

          if matches is None:
            return False

          self._SetRegexMatches(matches)
          return True

        if op_id == Id.Redir_Less:  # pun
          return s1 < s2

        if op_id == Id.Redir_Great:  # pun
          return s1 > s2

        raise NotImplementedError(op_id)

    raise AssertionError(node.tag)
Example #43
0
def stat(path):
       if cache.has_key(path):
               return cache[path]
       cache[path] = ret = posix.stat(path)
       return ret
Example #44
0
import posix
import sys

# read the contents of this file
fd = posix.open(__file__, posix.O_RDONLY)
data = posix.read(fd, 1024)
posix.close(fd)
print('the file\'s read size is %d bytes' % len(data))

# check that the file's stat shows the correct size
st = posix.stat(__file__)
print('the file\'s stat size is %d bytes' % st.st_size)
 def test_stat(self):
     if hasattr(posix, 'stat'):
         self.assert_(posix.stat(test_support.TESTFN))
Example #46
0
import posix

for file in posix.listdir("."):
    print file, posix.stat(file)[6]

## aifc-example-1.py 314
## anydbm-example-1.py 259
## array-example-1.py 48
def Method1():
    global code
    user_id = getUserID(input('# Type your user login ID : '))
    for entry in posix.listdir('/proc/'):
        if entry.isnumeric() == True:
            if posix.stat('/proc/' + entry).st_uid == user_id:
                code = 'Continue'
                break
    if code == 'Continue':
        print('# Any process belonged to typed user is found.')
        while True:
            option = input(
                '# Do you want to send signal to these processes for closing? (Y/N) : '
            )
            if option in ['Y', 'N']:
                break
        if option == 'N':
            code = 'Cancelled'
            return
        else:
            print('# Retriving processes list...')
            pids = []
            for entry in posix.listdir('/proc/'):
                if entry.isnumeric() == True:
                    if posix.stat('/proc/' + entry).st_uid == user_id:
                        pids.append(int(entry))
            print('# Quitting processes...')
            if posix.getuid() != user_id and posix.getuid() != 0:
                print(
                    '# Error : Don\'t have enough permission. Make sure to run this troubleshooter as root.'
                )
                code = 'RequiredRoot'
                return
            for pid in pids:
                posix.kill(pid, 15)
            input(
                'Waiting for processes to be closed properly (Recommended at 20 seconds). When ready then press enter.'
            )
            print('# Retriving processes list...')
            pids = []
            for entry in posix.listdir('/proc/'):
                if entry.isnumeric() == True:
                    if posix.stat('/proc/' + entry).st_uid == user_id:
                        pids.append(int(entry))
            if pids:
                while True:
                    option = input(
                        '# There are processes not quitted by the signal. Do you want to force killing it? (Y/N) : '
                    )
                    if option in ['Y', 'N']:
                        break
                if option == 'N':
                    code = 'Cancelled'
                    return
                print('# Killing processes...')
                for pid in pids:
                    posix.kill(pid, 9)
            code = 'Complete'
            return
    else:
        print('# No any process belonged to typed user is found.')
        code = 'NoSolution'
        return
Example #48
0
def copymode(src, dst):
    st = posix.stat(src)
    mode = divmod(st[0], MODEBITS)[1]
    posix.chmod(dst, mode)
Example #49
0
def samefile(f1, f2):
    s1 = posix.stat(f1)
    s2 = posix.stat(f2)
    return samestat(s1, s2)
Example #50
0
def copystat(src, dst):
    st = posix.stat(src)
    mode = divmod(st[0], MODEBITS)[1]
    posix.chmod(dst, mode)
    posix.utimes(dst, st[7:9])
Example #51
0
def copymode(src, dst):
       st = posix.stat(src)
       mode = divmod(st[0], MODEBITS)[1]
       posix.chmod(dst, mode)