File Manager

Hackfut Security File Manager

Current Path: /usr/lib/python2.6/site-packages/supervisor

usr / lib / python2.6 / site-packages / supervisor /

📁 ..
📄 __init__.py(8 B)
📄 __init__.pyc(142 B)
📄 __init__.pyo(142 B)
📄 datatypes.py(6.49 KB)
📄 datatypes.pyc(8.88 KB)
📄 datatypes.pyo(8.83 KB)
📄 http.py(25.91 KB)
📄 http.pyc(22.23 KB)
📄 http.pyo(22.23 KB)
📄 http_client.py(6.14 KB)
📄 http_client.pyc(8.55 KB)
📄 http_client.pyo(8.48 KB)
📁 medusa
📄 options.py(54.15 KB)
📄 options.pyc(48.25 KB)
📄 options.pyo(48.25 KB)
📄 pidproxy.py(1.75 KB)
📄 pidproxy.pyc(2.6 KB)
📄 pidproxy.pyo(2.6 KB)
📄 supervisorctl.py(20.99 KB)
📄 supervisorctl.pyc(19.57 KB)
📄 supervisorctl.pyo(19.57 KB)
📄 supervisord.py(26.85 KB)
📄 supervisord.pyc(21.6 KB)
📄 supervisord.pyo(21.49 KB)
📄 test.py(114.79 KB)
📄 test.pyc(114.47 KB)
📄 test.pyo(114.47 KB)
📁 ui
📄 web.py(17.15 KB)
📄 web.pyc(14.67 KB)
📄 web.pyo(14.67 KB)
📄 xmlrpc.py(31.89 KB)
📄 xmlrpc.pyc(27.01 KB)
📄 xmlrpc.pyo(26.9 KB)

Editing: datatypes.py

import os
import sys

if sys.platform[:3] == "win":
    DEFAULT_HOST = "localhost"
else:
    DEFAULT_HOST = ""

def integer(value):
    try:
        return int(value)
    except ValueError:
        return long(value)
    except OverflowError:
        return long(value)

def boolean(s):
    """Convert a string value to a boolean value."""
    ss = str(s).lower()
    if ss in ('yes', 'true', 'on', '1'):
        return True
    elif ss in ('no', 'false', 'off', '0'):
        return False
    else:
        raise ValueError("not a valid boolean value: " + repr(s))

def list_of_ints(arg):
    if not arg:
        return []
    else:
        return map(int, arg.split(","))

def dict_of_key_value_pairs(arg):
    """ parse KEY=val,KEY2=val2 into {'KEY':'val', 'KEY2':'val2'} """
    D = {}
    pairs = [ x.strip() for x in arg.split(',') ]
    pairs = filter(None, pairs)
    for pair in pairs:
        try:
            k, v = pair.split('=', 1)
        except ValueError:
            raise ValueError('Unknown key/value pair %s' % pair)
        D[k] = v
    return D

class RangeCheckedConversion:
    """Conversion helper that range checks another conversion."""

def __init__(self, conversion, min=None, max=None):
        self._min = min
        self._max = max
        self._conversion = conversion

def __call__(self, value):
        v = self._conversion(value)
        if self._min is not None and v < self._min:
            raise ValueError("%s is below lower bound (%s)"
                             % (`v`, `self._min`))
        if self._max is not None and v > self._max:
            raise ValueError("%s is above upper bound (%s)"
                             % (`v`, `self._max`))
        return v

port_number = RangeCheckedConversion(integer, min=1, max=0xffff).__call__

def inet_address(s):
    # returns (host, port) tuple
    host = ''
    port = None
    if ":" in s:
        host, s = s.split(":", 1)
        if s:
            port = port_number(s)
        host = host.lower()
    else:
        try:
            port = port_number(s)
        except ValueError:
            if len(s.split()) != 1:
                raise ValueError("not a valid host name: " + repr(s))
            host = s.lower()
    if not host:
        host = DEFAULT_HOST
    return host, port

class SocketAddress:
    def __init__(self, s):
        # returns (family, address) tuple
        import socket
        if "/" in s or s.find(os.sep) >= 0 or ":" not in s:
            self.family = getattr(socket, "AF_UNIX", None)
            self.address = s
        else:
            self.family = socket.AF_INET
            self.address = inet_address(s)

def dot_separated_user_group(arg):
    try:
        result = arg.split('.', 1)
        if len(result) == 1:
            username = result[0]
            uid = name_to_uid(username)
            if uid is None:
                raise ValueError('Invalid user name %s' % username)
            return (uid, -1)
        else:
            username = result[0]
            groupname = result[1]
            uid = name_to_uid(username)
            gid = name_to_gid(groupname)
            if uid is None:
                raise ValueError('Invalid user name %s' % username)
            if gid is None:
                raise ValueError('Invalid group name %s' % groupname)
            return (uid, gid)
        return result
    except:
        raise ValueError, 'Invalid user.group definition %s' % arg

def octal_type(arg):
    return int(arg, 8)

def name_to_uid(name):
    import pwd
    try:
	uid = int(name)
    except ValueError:
	try:
	    pwrec = pwd.getpwnam(name)
	except KeyError:
            return None
	uid = pwrec[2]
    else:
	try:
	    pwrec = pwd.getpwuid(uid)
	except KeyError:
            return None
    return uid

def name_to_gid(name):
    import grp
    try:
	gid = int(name)
    except ValueError:
	try:
	    pwrec = grp.getgrnam(name)
	except KeyError:
            return None
	gid = pwrec[2]
    else:
	try:
	    pwrec = grp.getgrgid(gid)
	except KeyError:
            return None
    return gid

def gid_for_uid(uid):
    import pwd
    pwrec = pwd.getpwuid(uid)
    return pwrec[3]

def existing_directory(v):
    import os
    nv = os.path.expanduser(v)
    if os.path.isdir(nv):
        return nv
    raise ValueError('%s is not an existing directory' % v)

def existing_dirpath(v):
    import os
    nv = os.path.expanduser(v)
    dir = os.path.dirname(nv)
    if not dir:
        # relative pathname with no directory component
        return nv
    if os.path.isdir(dir):
        return nv
    raise ValueError, ('The directory named as part of the path %s '
                       'does not exist.' % v)

_logging_levels = {
    "critical": 50,
    "fatal": 50,
    "error": 40,
    "warn": 30,
    "warning": 30,
    "info": 20,
    "blather": 15,
    "debug": 10,
    "trace": 5,
    "all": 1,
    "notset": 0,
    }

def logging_level(value):
    s = str(value).lower()
    if _logging_levels.has_key(s):
        return _logging_levels[s]
    else:
        v = int(s)
        if v < 0 or v > 50:
            raise ValueError("log level not in range: " + `v`)
        return v

class SuffixMultiplier:
    # d is a dictionary of suffixes to integer multipliers.  If no suffixes
    # match, default is the multiplier.  Matches are case insensitive.  Return
    # values are in the fundamental unit.
    def __init__(self, d, default=1):
        self._d = d
        self._default = default
        # all keys must be the same size
        self._keysz = None
        for k in d.keys():
            if self._keysz is None:
                self._keysz = len(k)
            else:
                assert self._keysz == len(k)

def __call__(self, v):
        v = v.lower()
        for s, m in self._d.items():
            if v[-self._keysz:] == s:
                return int(v[:-self._keysz]) * m
        return int(v) * self._default

byte_size = SuffixMultiplier({'kb': 1024,
                              'mb': 1024*1024,
                              'gb': 1024*1024*1024L,})

def url(value):
    import urlparse
    scheme, netloc, path, params, query, fragment = urlparse.urlparse(value)
    if scheme and netloc:
        return value
    raise ValueError("value %s is not a URL" % value)

def signal(value):
    import signal
    result = None
    try:
        result = int(value)
    except (ValueError, TypeError):
        result = getattr(signal, 'SIG'+value, None)
    try:
        result = int(result)
        return result
    except (ValueError, TypeError):
        raise ValueError('value %s is not a signal name/number' % value)

Hackfut Security File Manager

Editing: datatypes.py

Upload File

Create Folder