Example #1
0
File: root.py Project: gmoro/jurt
            **kwargs):
        super(BtrfsChrootManager, self).__init__(*args, **kwargs)
        self.newsvcmd = newsvcmd
        self.snapsvcmd = snapsvcmd
        self.delsvcmd = delsvcmd
        self.targetname = targetname

    def create_new(self, name, packagemanager, repos, logstore):
        templatepath = os.path.join(self.topdir, self.targetname)
        rootpath = self.path_from_name(name)
        if not os.path.exists(templatepath):
            self.su().btrfs_create(rootpath)
            root = ChrootRootManager.create_new(self, name,
                    packagemanager, repos, logstore)
            self.su().btrfs_snapshot(rootpath, templatepath)
        else:
            self.su().btrfs_snapshot(templatepath, rootpath)
            root = Chroot(self, rootpath, self._root_arch(packagemanager))
            self._update_latest_link(rootpath)
        return root

root_managers = Registry("root type")
root_managers.register("chroot", ChrootRootManager)
root_managers.register("chroot-with-cache", CompressedChrootManager)
root_managers.register("chroot-with-btrfs", BtrfsChrootManager)

def get_root_manager(suwrapper, rootconf, globalconf):
    klass_ = root_managers.get_class(rootconf.root_type)
    instance = klass_(**klass_.load_config(suwrapper, rootconf, globalconf))
    return instance
Example #2
0
File: su.py Project: gmoro/jurt
        return self.suwrapper.add_user(username, uid, gid, self.path)

    def run_package_manager(self, pmname, pmargs, outputlogger=None):
        return self.suwrapper.run_package_manager(pmname, pmargs,
                root=self.path, arch=self.arch, outputlogger=outputlogger)

    def run_as(self, args, user, timeout=None, outputlogger=None):
        return self.suwrapper.run_as(args, user=user, root=self.path,
                arch=self.arch, timeout=timeout, outputlogger=outputlogger)

    def post_root_command(self):
        return self.suwrapper.post_root_command(root=self.path, arch=self.arch)

    def interactive_prepare_conf(self, username):
        return self.suwrapper.interactive_prepare_conf(username, root=self.path,
                arch=self.arch)

    def interactive_shell(self, username):
        return self.suwrapper.interactive_shell(username, root=self.path,
                arch=self.arch)

    def __getattr__(self, name):
        return getattr(self.suwrapper, name)

su_wrappers = Registry("sudo wrapper")
su_wrappers.register("jurt-root-wrapper", JurtRootWrapper)

def get_su_wrapper(targetname, suconf, globalconf):
    klass = su_wrappers.get_class(suconf.su_type)
    return klass(**klass.load_config(targetname, suconf, globalconf))
Example #3
0
    def get_output_handler(self, name, trap=None):
        path = os.path.join(self.path, name) + ".log"
        fileobj = OutputLogger(path, trap=trap, outputfile=self.outputfile)
        logger.debug("created log file %s" % (path))
        fileobj.start()
        self.logfiles.append(path)
        return fileobj

    def done(self):
        pass

    def logs(self):
        found = []
        for subid, pkg in self.subpackages:
            for path in pkg.logfiles:
                found.append((subid, path))
        return self.id, found

    def subpackage(self, subid):
        logger = Logger(subid, self.path, outputfile=self.outputfile)
        self.subpackages.append((subid, logger))
        return logger

loggers = Registry("logger type")
loggers.register("default", LoggerFactory)

def get_logger_factory(loggerconf, globalconf):
    instance = loggers.get_instance(loggerconf.logger_type, loggerconf,
            globalconf)
    return instance
Example #4
0
        for opt, value in opts:
            if opt == "--root" or opt == "--urpmi-root":
                absroot = os.path.abspath(value) + "/"
                if not absroot.startswith(absrootsdir):
                    raise CommandValidationError, "%s should be " "based on %s" % (opt, absrootsdir)

    # run as root
    def cmd_args(self, pmtype, args):
        if pmtype == "urpmi":
            return self.urpmicmd[:] + args
        elif pmtype == "urpmi.addmedia":
            return self.addmediacmd[:] + args
        elif pmtype == "urpmi.update":
            return self.updatecmd[:] + args
        else:
            raise PackageManagerError, "invalid package manager"

    # run as root
    def allowed_pm_commands(self):
        return self.allowedpmcmds[:]


package_managers = Registry("package manager type")
package_managers.register("urpmi", URPMIPackageManager)


def get_package_manager(pmconf, globalconf):
    klass = package_managers.get_class(pmconf.pm_type)
    instance = klass(**klass.load_config(pmconf, globalconf))
    return instance
Example #5
0
        for arg in args:
            if "=" in args:
                name, value = arg.split("=", 1)
                if name in ("rpm-root", "data-dir"):
                    absroot = os.path.abspath(value) + "/"
                    if not absroot.startswith(absrootsdir):
                        raise CommandValidationError, "%s should be "\
                                "based on %s" % (opt, absrootsdir)

    def cmd_args(self, pmtype, args):
        if pmtype == "smart.install":
            return self.installcmd[:] + args
        elif pmtype == "smart.addchannel":
            return self.addchannelcmd[:] + args
        elif pmtype == "smart.update":
            return self.updatecmd[:] + args
        else:
            raise PackageManagerError, "invalid package manager"

    def allowed_pm_commands(self):
        return self.allowedrpmcmds + self.allowedsmartcmds

package_managers = Registry("package manager type")
package_managers.register("urpmi", URPMIPackageManager)
package_managers.register("smart+urpmi", SmartPackageManager)

def get_package_manager(pmconf, globalconf):
    instance = package_managers.get_instance(pmconf.pm_type, pmconf,
            globalconf)
    return instance
Example #6
0
File: build.py Project: gmoro/jurt
            if existing:
                name = id
            root = self.rootmanager.get_root_by_name(name, self.packagemanager)
        else:
            root = self.rootmanager.create_new(id, self.packagemanager, self.repos, logstore)
        root.mount()
        try:
            username, uid = self.build_user_info()
            if not existing and not latest:
                self.packagemanager.setup_repositories(root, self.repos, logstore)
                root.add_user(username, uid)
                root.interactive_prepare(username, uid, self.packagemanager, self.repos, logstore)
                homedir = self.build_user_home(username)
                self.packagemanager.build_prepare(root, homedir, username, uid)
            root.interactive_shell(username)
        finally:
            root.umount()

    def set_interactive(self):
        self.interactive = True


build_types = Registry("builder type")
build_types.register("default", Builder)


def get_builder(rootmanager, packagemanager, buildconf, globalconf):
    klass_ = build_types.get_class(buildconf.build_type)
    instance = klass_(**klass_.load_config(rootmanager, packagemanager, buildconf, globalconf))
    return instance