Beispiel #1
0
class grubParser:
    def __init__(self, _dir, write=False, timeout=-1):
        self.dir = _dir
        self.write = write
        self.grub_conf = os.path.join(_dir, "grub.conf")

        self.lock = FileLock("%s/.grub.lock" % _dir)
        try:
            self.lock.lock(write, timeout)
        except IOError:
            fail(FAIL_TIMEOUT)

        # Fail if grub is not installed
        if os.path.exists(self.grub_conf):
            self.config = grubConf()
            self.config.parseConf(self.grub_conf)
        else:
            self.fail(FAIL_NOGRUB)

    def fail(self, msg):
        self.lock.unlock()
        fail(msg)

    def release(self, save=True):
        if save and self.write:
            self.config.write(self.grub_conf)
        self.lock.unlock()
Beispiel #2
0
class grubParser:
    def __init__(self, _dir, write=False, timeout=-1):
        self.dir = _dir
        self.write = write
        self.grub_conf = os.path.join(_dir, "grub.conf")
        
        self.lock = FileLock("%s/.grub.lock" % _dir)
        try:
            self.lock.lock(write, timeout)
        except IOError:
            fail(FAIL_TIMEOUT)
        
        # Fail if grub is not installed
        if os.path.exists(self.grub_conf):
            self.config = grubConf()
            self.config.parseConf(self.grub_conf)
        else:
            self.fail(FAIL_NOGRUB)
    
    def fail(self, msg):
        self.lock.unlock()
        fail(msg)
    
    def release(self, save=True):
        if save and self.write:
            self.config.write(self.grub_conf)
        self.lock.unlock()
Beispiel #3
0
class Lock:
    def __init__(self, _file, shared=False):
        lockfile = os.path.join(os.path.dirname(_file), ".%s" % os.path.basename(_file))
        try:
            self.lock = FileLock(_file)
            self.lock.lock(timeout=TIMEOUT, shared=shared)
        except IOError:
            fail(FAIL_TIMEOUT)

    def release(self):
        self.lock.unlock()
Beispiel #4
0
class Lock:
    def __init__(self, _file, shared=False):
        lockfile = os.path.join(os.path.dirname(_file), ".%s" % os.path.basename(_file))
        try:
            self.lock = FileLock(_file)
            self.lock.lock(timeout=TIMEOUT, shared=shared)
        except IOError:
            fail(FAIL_TIMEOUT)
    
    def release(self):
        self.lock.unlock()
Beispiel #5
0
def setConf(key, value=None):
    lock = FileLock(CONF)
    lock.lock(shared=False)
    data = file(CONF).read()
    lines = data.split("\n")
    for index, line in enumerate(lines):
        try:
            _key, _value = line.split("=", 1)
        except ValueError:
            continue
        _key = _key.strip()
        if key == _key or (_key.startswith("#") and _key[1:].strip() == key):
            if value:
                lines[index] = "%s = '%s'" % (key, value)
            elif not line.startswith("#"):
                lines[index] = "# %s" % line
    file(CONF, "w").write("\n".join(lines))
    lock.unlock()
Beispiel #6
0
def getConf(key, default=None):
    lock = FileLock(CONF)
    lock.lock(shared=True)
    value = default
    for line in file(CONF):
        line = line.strip()
        try:
            _key, _value = line.split("=", 1)
        except ValueError:
            continue
        _key = _key.strip()
        if key == _key:
            value = _value.strip()
            if value.startswith('"') or value.startswith("'"):
                value = value[1:-1]
            break
    lock.unlock()
    return value
Beispiel #7
0
def setConf(key, value=None):
    lock = FileLock(CONF)
    lock.lock(shared=False)
    data = file(CONF).read()
    lines = data.split("\n")
    for index, line in enumerate(lines):
        try:
            _key, _value = line.split("=", 1)
        except ValueError:
            continue
        _key = _key.strip()
        if key == _key or (_key.startswith("#") and _key[1:].strip() == key):
            if value:
                lines[index] = "%s = '%s'" % (key, value)
            elif not line.startswith("#"):
                lines[index] = "# %s" % line
    file(CONF, "w").write("\n".join(lines))
    lock.unlock()
Beispiel #8
0
def getConf(key, default=None):
    lock = FileLock(CONF)
    lock.lock(shared=True)
    value = default
    for line in file(CONF):
        line = line.strip()
        try:
            _key, _value = line.split("=", 1)
        except ValueError:
            continue
        _key = _key.strip()
        if key == _key:
            value = _value.strip()
            if value.startswith('"') or value.startswith("'"):
                value = value[1:-1]
            break
    lock.unlock()
    return value
Beispiel #9
0
class Database:
    passwd_path = "/etc/passwd"
    shadow_path = "/etc/shadow"
    group_path = "/etc/group"
    lock_path = "/etc/.pwd.lock"

    def __init__(self, for_read=False):
        self.lock = FileLock(self.lock_path)
        self.lock.lock(shared=for_read)

        self.users = {}
        self.users_by_name = {}
        self.groups = {}
        self.groups_by_name = {}

        for line in file(self.passwd_path):
            if line != "" and line != "\n":
                parts = line.rstrip("\n").split(":")
                user = User()
                user.name = parts[0]
                user.uid = int(parts[2])
                user.gid = int(parts[3])
                user.realname = parts[4]
                user.homedir = parts[5]
                user.shell = parts[6]
                self.users[user.uid] = user
                self.users_by_name[user.name] = user

        for line in file(self.shadow_path):
            if line != "" and line != "\n":
                parts = line.rstrip("\n").split(":")
                if self.users_by_name.has_key(parts[0]):
                    user = self.users_by_name[parts[0]]
                    user.password = parts[1]
                    user.pwrest = parts[2:]

        for line in file(self.group_path):
            if line != "" and line != "\n":
                parts = line.rstrip("\n").split(":")
                group = Group()
                group.name = parts[0]
                group.gid = int(parts[2])
                group.members = parts[3].split(",")
                if "" in group.members:
                    group.members.remove("")
                self.groups[group.gid] = group
                self.groups_by_name[group.name] = group

    def sync(self):
        lines = []
        keys = self.users.keys()
        keys.sort()
        for uid in keys:
            user = self.users[uid]
            lines.append("%s:x:%d:%d:%s:%s:%s\n" % (
                user.name, uid, user.gid,
                user.realname, user.homedir, user.shell
            ))
        f = file(self.passwd_path, "w")
        f.writelines(lines)
        f.close()

        lines = []
        keys = self.users.keys()
        keys.sort()
        for uid in keys:
            user = self.users[uid]
            if user.password:
                lines.append("%s:%s:%s\n" % (
                    user.name,
                    user.password,
                    ":".join(user.pwrest)
                ))
            else:
                lines.append("%s::13094:0:99999:7:::\n" % user.name)
        f = file(self.shadow_path, "w")
        f.writelines(lines)
        f.close()

        lines = []
        keys = self.groups.keys()
        keys.sort()
        for gid in keys:
            group = self.groups[gid]
            lines.append("%s:x:%s:%s\n" % (group.name, gid, ",".join(group.members)))
        f = file(self.group_path, "w")
        f.writelines(lines)
        f.close()

    def set_groups(self, name, grouplist):
        for gid in self.groups.keys():
            g = self.groups[gid]
            if name in g.members:
                if not g.name in grouplist:
                    g.members.remove(name)
            else:
                if g.name in grouplist:
                    g.members.append(name)

    def next_uid(self):
        for i in range(uid_minimum, uid_maximum):
            if not self.users.has_key(i):
                return i

    def next_gid(self):
        for i in range(uid_minimum, uid_maximum):
            if not self.groups.has_key(i):
                return i
Beispiel #10
0
class Database:
    passwd_path = "/etc/passwd"
    shadow_path = "/etc/shadow"
    group_path = "/etc/group"
    lock_path = "/etc/.pwd.lock"
    
    def __init__(self, for_read=False):
        self.lock = FileLock(self.lock_path)
        self.lock.lock(shared=for_read)
        
        self.users = {}
        self.users_by_name = {}
        self.groups = {}
        self.groups_by_name = {}
        
        for line in file(self.passwd_path):
            if line != "" and line != "\n":
                parts = line.rstrip("\n").split(":")
                user = User()
                user.name = parts[0]
                user.uid = int(parts[2])
                user.gid = int(parts[3])
                user.realname = parts[4]
                user.homedir = parts[5]
                user.shell = parts[6]
                self.users[user.uid] = user
                self.users_by_name[user.name] = user
        
        for line in file(self.shadow_path):
            if line != "" and line != "\n":
                parts = line.rstrip("\n").split(":")
                if self.users_by_name.has_key(parts[0]):
                    user = self.users_by_name[parts[0]]
                    user.password = parts[1]
                    user.pwrest = parts[2:]
        
        for line in file(self.group_path):
            if line != "" and line != "\n":
                parts = line.rstrip("\n").split(":")
                group = Group()
                group.name = parts[0]
                group.gid = int(parts[2])
                group.members = parts[3].split(",")
                if "" in group.members:
                    group.members.remove("")
                self.groups[group.gid] = group
                self.groups_by_name[group.name] = group
    
    def sync(self):
        lines = []
        keys = self.users.keys()
        keys.sort()
        for uid in keys:
            user = self.users[uid]
            lines.append("%s:x:%d:%d:%s:%s:%s\n" % (
                user.name, uid, user.gid,
                user.realname, user.homedir, user.shell
            ))
        f = file(self.passwd_path, "w")
        f.writelines(lines)
        f.close()
        
        lines = []
        keys = self.users.keys()
        keys.sort()
        for uid in keys:
            user = self.users[uid]
            if user.password:
                lines.append("%s:%s:%s\n" % (
                    user.name,
                    user.password,
                    ":".join(user.pwrest)
                ))
        f = file(self.shadow_path, "w")
        f.writelines(lines)
        f.close()
        
        lines = []
        keys = self.groups.keys()
        keys.sort()
        for gid in keys:
            group = self.groups[gid]
            lines.append("%s:x:%s:%s\n" % (group.name, gid, ",".join(group.members)))
        f = file(self.group_path, "w")
        f.writelines(lines)
        f.close()
    
    def set_groups(self, name, grouplist):
        for gid in self.groups.keys():
            g = self.groups[gid]
            if name in g.members:
                if not g.name in grouplist:
                    g.members.remove(name)
            else:
                if g.name in grouplist:
                    g.members.append(name)
    
    def next_uid(self):
        for i in range(uid_minimum, uid_maximum):
            if not self.users.has_key(i):
                return i
    
    def next_gid(self):
        for i in range(uid_minimum, uid_maximum):
            if not self.groups.has_key(i):
                return i
Beispiel #11
0
class iniDB:
    def __init__(self, db_file, db_mode=0600):
        try:
            os.makedirs(os.path.dirname(db_file))
        except OSError:
            pass
        self.db_file = db_file
        self.lock_file = os.path.join(os.path.dirname(db_file), '.%s' % os.path.basename(db_file))
        if not os.path.exists(db_file):
            self.__writelock()
            file(db_file, "w").close()
            os.chmod(db_file, db_mode)
            self.__unlock()
        self.__readlock()
        self.cp = ConfigParser.ConfigParser()
        self.cp.read(db_file)
        self.__unlock()

    def __writelock(self):
        self.fl = FileLock(self.lock_file)
        self.fl.lock(shared=False)

    def __readlock(self):
        self.fl = FileLock(self.lock_file)
        self.fl.lock(shared=True)

    def __unlock(self):
        self.fl.unlock()

    def listDB(self):
        profiles = self.cp.sections()
        if "general" in profiles:
            profiles.remove("general")
        return profiles

    def getDB(self, name):
        dct = {}
        if name in self.cp.sections():
            dct = dict(self.cp.items(name))
        return dct

    def setDB(self, name, dct):
        for key, value in dct.iteritems():
            if value:
                if name not in self.cp.sections():
                    self.cp.add_section(name)
                self.cp.set(name, key, value)
            elif name in self.cp.sections():
                self.cp.remove_option(name, key)
        self.__writelock()
        fp = open(self.db_file, "w")
        self.cp.write(fp)
        fp.close()
        self.__unlock()

    def remDB(self, name):
        self.cp.remove_section(name)
        self.__writelock()
        fp = open(self.db_file, "w")
        self.cp.write(fp)
        fp.close()
        self.__unlock()
Beispiel #12
0
class iniParser:
    """
        INI file parsing and manipulation class.

        ip = iniParser("my.ini", [chmod=0600, [quiet=False]])
        ip.listSections() => ["section1", "section2", ...]
        ip.getSection("section1") => {"field1": "value1", "field2": "value2"}
        ip.setSection("section1",{"field1": "value1", "field2": "value2"})
        ip.removeSection("section2")

    """

    def __init__(self, inifile, chmod=0o600, quiet=False):
        """
            Constuctor. Creates INI file if it doesn't exist and sets file mode.
        """
        self.inifile = inifile
        self.chmod = chmod
        self.quiet = quiet
        try:
            os.makedirs(os.path.dirname(inifile))
        except OSError:
            pass
        if not os.path.exists(inifile):
            self.__writeLock()
            open(inifile, "w").close()
            self.__unlock()
        os.chmod(inifile, chmod)

    def __writeLock(self):
        """
            Puts a write lock to file.
        """
        self.fl = FileLock(self.inifile)
        self.fl.lock(shared=False)

    def __readLock(self):
        """
            Puts a read lock to file.
        """
        self.fl = FileLock(self.inifile)
        self.fl.lock(shared=True)

    def __unlock(self):
        """
            Removes lock from file.
        """
        self.fl.unlock()

    def __readIni(self):
        """
            Gets content of the INI.
        """
        ini = configparser.ConfigParser()
        try:
            ini.read(self.inifile)
        except configparser.Error:
            ini = None
        return ini

    def __writeIni(self, ini):
        """
            Writes INI to file.
        """
        fp = open(self.inifile, "w")
        ini.write(fp)
        fp.close()

    def listSections(self):
        """
            Lists sections of INI file.
        """
        self.__readLock()
        ini = self.__readIni()
        self.__unlock()
        if not ini:
            if self.quiet:
                self.__fixIniFile()
                return []
            else:
                raise iniParserError("File is corrupt: %s" % self.inifile)
        return ini.sections()

    def getSection(self, section):
        """
            Returns a section of INI file.
        """
        self.__readLock()
        ini = self.__readIni()
        self.__unlock()
        if not ini:
            if self.quiet:
                self.__fixIniFile()
                return {}
            else:
                raise iniParserError("File is corrupt: %s" % self.inifile)
        if section not in ini.sections():
            return {}
        dct = {}
        if section in ini.sections():
            dct = dict(ini.items(section))
        return dct

    def setSection(self, section, dct):
        """
            Sets a section of INI file.
        """
        self.__writeLock()
        ini = self.__readIni()
        if not ini:
            self.__unlock()
            if self.quiet:
                self.__fixIniFile()
                self.setSection(section, dct)
                return
            else:
                raise iniParserError("File is corrupt: %s" % self.inifile)
        if section not in ini.sections():
            ini.add_section(section)
        for key, value in dct.items():
            if value:
                ini.set(section, key, value)
            elif section in ini.sections():
                ini.remove_option(section, key)
        self.__writeIni(ini)
        self.__unlock()

    def removeSection(self, section):
        """
            Removes a section from INI file.
        """
        self.__writeLock()
        ini = self.__readIni()
        if not ini:
            self.__unlock()
            if self.quiet:
                self.__fixIniFile()
                return
            else:
                raise iniParserError("File is corrupt: %s" % self.inifile)
        ini.remove_section(section)
        self.__writeIni(ini)
        self.__unlock()

    def __fixIniFile(self):
        """
            Cleans bogus ini file.
        """
        self.__writeLock()
        open(self.inifile, "w").write("")
        self.__unlock()
Beispiel #13
0
class iniDB:
    def __init__(self, db_file, db_mode=0o600):
        try:
            os.makedirs(os.path.dirname(db_file))
        except OSError:
            pass
        self.db_file = db_file
        if not os.path.exists(db_file):
            self.__writelock()
            open(db_file, "w").close()
            os.chmod(db_file, db_mode)
            self.__unlock()
        self.__readlock()
        self.cp = configparser.ConfigParser()
        try:
            self.cp.read(db_file)
        except:
            print("Network configuration file %s is corrupt" % db_file)
        self.__unlock()

    def __writelock(self):
        self.fl = FileLock(self.db_file)
        self.fl.lock(shared=False)

    def __readlock(self):
        self.fl = FileLock(self.db_file)
        self.fl.lock(shared=True)

    def __unlock(self):
        self.fl.unlock()

    def listDB(self):
        profiles = self.cp.sections()
        if "general" in profiles:
            profiles.remove("general")
        return profiles

    def getDB(self, name):
        dct = {}
        if name in self.cp.sections():
            dct = dict(self.cp.items(name))
        return dct

    def setDB(self, name, dct):
        for key, value in dct.items():
            if value:
                if name not in self.cp.sections():
                    self.cp.add_section(name)
                self.cp.set(name, key, value)
            elif name in self.cp.sections():
                self.cp.remove_option(name, key)
        # FIXME: This is an ugly hack...
        db = iniDB(self.db_file)
        for nm in db.listDB():
            if nm == name:
                continue
            for key, value in db.getDB(nm).items():
                self.cp.set(nm, key, value)
        self.__writelock()
        fp = open(self.db_file, "w")
        self.cp.write(fp)
        fp.close()
        self.__unlock()

    def remDB(self, name):
        self.cp.remove_section(name)
        self.__writelock()
        fp = open(self.db_file, "w")
        self.cp.write(fp)
        fp.close()
        self.__unlock()