def __init__(self, cmd, args, cwd, verbose, env=None): super(Command, self).__init__(env) self.cmd = cmd self.args = args self.cwd_dir = real_path(cwd) self.verbose = verbose self.log = kaizen.logging.getLogger(self)
def extract(self): self.log.info("Extracting rules %r" % self.rules_name) if self.rules.extract_cmd: extractor = self.rules.extract_cmd(self.rules.url) extractor.extract(self.data_dir, self.src_dir) self.install_directories.source = real_path(self.rules.src_path) self._update_install_directories()
def __init__(self, args, src_dir, build_dir, verbose=False, env=None): super(BuildSystem, self).__init__(env) self.args = args self.src_dir = src_dir self.build_dir = build_dir self.cwd_dir = real_path(build_dir) self.verbose = verbose self.log = kaizen.logging.getLogger(self)
def run(self): cmd = ["cmake"] cmd.extend(self.args) cmd.append(real_path(self.src_dir)) self.log.debug("CMake run '%s' in '%s' with env '%s'" % (cmd, self.cwd_dir, self.env)) process = Process(cmd) process.run(not self.verbose, extra_env=self.env, cwd=self.cwd_dir)
def build(self): self.log.info("Build rules %r" % self.rules_name) self._groups_call("pre_build") self.rules.pre_build() self.rules.build() self.rules.post_build() self.install_directories.build = real_path(self.rules.build_path) self._update_install_directories() self._groups_call("post_build")
def download(self): self.log.info("Download of rules %r" % self.rules_name) if not os.path.exists(self.data_dir): self.log.debug("Creating download directory %r" % self.data_dir) os.makedirs(self.data_dir) if self.rules.url and self.rules.download_cmd: self.log.info("Copying source file from '%s'." % self.rules.url) (archive_source, archive_dest) = self._get_download(self.rules.url, self.data_dir) dl = self.rules.download_cmd(self.rules, archive_source) download_file = dl.copy(archive_dest, self.force) dl.verify(self.rules.hash) self.install_directories.download = real_path(download_file) self.db.session.add(self.install_directories) self.db.session.commit()
def create(self, stdout=False): if not os.path.isdir(self.dir): os.makedirs(self.dir) self.tmp_dir = mkdtemp(prefix="tmp-rules-", dir=self.dir) self.log.debug("Created temporary directory '%s'" % self.tmp_dir) downloader = UrlDownloader(None, self.url) source = downloader.copy(self.tmp_dir) hashcalc = Hash(source) md5 = hashcalc.md5() self.log.debug("md5 hash is '%s'" % md5) sha1 = hashcalc.sha1() self.log.debug("sha1 hash is '%s'" % sha1) filename = os.path.basename(source) if not "-" in filename and (not self.name or not self.version): self.clean() raise RulesCreateError("Could not detect name and "\ "version from file '%s'" % filename) if "-" in filename: suffixes = [".tar.gz", ".tar.bz2", ".tgz", "tbz2", ".zip"] for suffix in suffixes: if filename.endswith(suffix): index = filename.rfind(suffix) filename = filename[:index] split = filename.rsplit("-", 1) detected_name = split[0] name = detected_name.lower() version = split[1] detected_version = version else: name = self.name version = self.version detected_name = self.name detected_version = self.version if not self.template: extract_file(source, self.tmp_dir) template = None for detector in detectors: if detector.detect(name, self.tmp_dir): template = detector.get_template() name = detector.get_name() break if not template: self.log.info("Could not detected template for '%s'. " "Using default." % name) template = Template("default.template") else: template = Template(self.templatename + ".template") self.log.debug("Detected rules name is '%s'" % detected_name) self.log.debug("Detected rules version is '%s'" % detected_version) self.log.info("Rules name is '%s'" % name) self.log.info("Rules version is '%s'" % version) vars = dict() vars["name"] = name vars["version"] = version vars["md5"] = md5 vars["sha1"] = sha1 vars["url"] = self.url vars["rootdir"] = self.dir vars["rules"] = self.rules_dir vars["rulesname"] = name.replace("-","").capitalize() vars["detectedname"] = detected_name vars["detectedversion"] = detected_version # self.name and self.version may contain templates if self.name: name = self.name % vars if self.version: version = self.version % vars if stdout: print template.replace(vars) else: new_rules_dir = os.path.join(real_path(self.rules_dir[0]), name) if not os.path.exists(new_rules_dir): os.makedirs(new_rules_dir) try: rulesfile = os.path.join(new_rules_dir, "rules.py") f = open(rulesfile, "w") self.log.info("Creating new rules file '%s'" % rulesfile) f.write(template.replace(vars)) finally: f.close() self.clean()
def __init__(self, config): super(RulesLoader, self).__init__() self.config = config self.log = kaizen.logging.getLogger(self) paths = self.config.get("rules") self.add_paths([real_path(path.strip()) for path in paths])
def __init__(self, files=[], options={}): self.preferred = {} self.config = {} defaults = {} # set default values defaults["debug"] = False defaults["quiet"] = False defaults["verbose"] = False defaults["prefix"] = "/usr/local" defaults["buildjobs"] = 1 # use preferred values from options for key in defaults.keys() + ["rules"]: if key in options and options[key]: self.preferred[key] = options[key] self.configparser = SafeConfigParser() self.configparser.read(files) if not self.configparser.has_section("kaizen"): self.configparser.add_section("kaizen") prefix = real_path(self._get("prefix", defaults["prefix"])) self.config["version"] = kaizen.__version__ self.config["prefix"] = prefix self.config["verbose"] = self._getbool("verbose", defaults["verbose"]) self.config["quiet"] = self._getbool("quiet", defaults["quiet"]) self.config["debug"] = self._getbool("debug", defaults["debug"]) self.config["rootdir"] = self._get("rootdir") self.config["rules"] = self._getlist("rules") self.config["destroot"] = self._get("destroot") self.config["downloadroot"] = self._get("downloadroot") self.config["buildroot"] = self._get("buildroot") self.config["debugdb"] = self._getbool("debugdb", False) self.config["system"] = self._get("system") self.config["buildjobs"] = self._getint("buildjobs", defaults["buildjobs"]) kaizen_package_path = os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir)) self.config["packagepath"] = kaizen_package_path kaizen_dir = self.config.get("rootdir", None) if not kaizen_dir: kaizen_dir = os.path.join(prefix, "kaizen") self.config["rootdir"] = kaizen_dir if not self.config.get("system", None): self.config["system"] = os.path.join(kaizen_dir, "system") if not self.config.get("downloadroot", None): self.config["downloadroot"] = os.path.join(kaizen_dir, "cache") if not self.config.get("rules"): self.config["rules"] = [os.path.join(kaizen_dir, "rules")] if not self.config.get("destroot", None): self.config["destroot"] = os.path.join(kaizen_dir, "destroot") if not self.config.get("buildroot", None): self.config["buildroot"] = os.path.join(kaizen_dir, "cache") if not self.config.get("appsdir", None): self.config["appsdir"] = os.path.join(prefix, "Applications") if not self.config.get("buildjobs") > 0: self.config["buildjobs"] = get_number_of_cpus() + 1
# You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA # 02110-1301 USA import os.path from ConfigParser import SafeConfigParser import kaizen from kaizen.utils import real_path, get_number_of_cpus from kaizen.error import KaizenRuntimeError KAIZEN_CONFIG_FILES = ["/etc/kaizenrc", real_path("~/.kaizen/kaizenrc")] class Config(object): """ Config class for several kaizen settings Variables are: * version - String: kaizen version * quiet - Bool: only return parsable output and don't display addition user related output * debug - Bool: debug is enabled/disabled (default is False) * verbose - Bool: commands should print it's output (default is False) * debugdb - Bool: database queries are printed (default is False) * prefix - String: absolute path to the prefix (default is /usr/local) * rootdir - String: path to the rootdir (default is %(prefix)s/kaizen) * downloadroot - String: path to the directory to put in downloaded source
def __init__(self, config, src_dir, build_dir, dest_dir): self.config = config self.build_dir = build_dir self.src_dir = src_dir self.dest_dir = dest_dir self.verbose = self.config.get("verbose") self.debug = self.config.get("debug") self.prefix = self.config.get("prefix") self.rules_dirs = self.config.get("rules") self.destroot_dir = self.config.get("destroot") self.buildjobs = self.config.get("buildjobs") # rules name must be in sync with wrapper rules name for destroot # installation. Currently it's not best to have different sources # for rules name. Changing the module layout for rules installation # could fail if a rules uses self.destdir_path then. # TODO: All parameters should be set by Wrapper self.rules_name = self.__module__.split(".")[-2] self.destroot_path = os.path.join(self.destroot_dir, self.rules_name, self.get_dist_version()) # TODO check if destroot_path and dest_dir are equal self.rules_path = real_path(os.path.dirname( inspect.getfile(self.__class__))) self.package_path = self.config.get("packagepath") self.apps_dir = self.config.get("appsdir") self.dest_path = self.destroot_path + self.prefix self.log = kaizen.logging.getLogger("kaizen.rules." + self.rules_name) self.__shadow = dict() if not self.name: self.name = self.rules_name self.vars = dict() self.vars["prefix"] = self.config.get("prefix") self.vars["rootdir"] = self.config.get("rootdir") self.vars["version"] = self.get_version() self.vars["revision"] = self.revision self.vars["name"] = self.name self.vars["src_dir"] = self.src_dir self.vars["build_dir"] = self.build_dir self.vars["rules_path"] = self.rules_path self.vars["dist_version"] = self.get_dist_version() self.vars["package_path"] = self.package_path self.vars["apps_dir"] = self.apps_dir self.vars["dest_path"] = self.dest_path if not self.src_path: self.src_path = os.path.join(src_dir, self.name + "-" + self.version) self.src_path = real_path(self.src_path) self.vars["src_path"] = self.src_path if not self.build_path: self.build_path = build_dir self.build_path = real_path(self.build_path) self.vars["build_path"] = self.build_path if not self.patch_path: self.patch_path = os.path.join(self.rules_path, "patches") self.patch_path = real_path(self.patch_path) self.vars["patch_path"] = self.patch_path # src_path may be differenct then the path to the sources where # e.g. configure should be run. A rules may copy the sources to # a different dir to be able to do clean builds. if not self.configure_path: self.configure_path = self.src_path self.vars["configure_path"] = self.configure_path groups = self.groups self._groups = [] for group in groups: self._groups.append(group(self, config)) self.init()
def __init__(self, dir, verbose=False, env=None): super(Make, self).__init__(env) self.dir = dir self.cwd_dir = real_path(dir) self.verbose = verbose self.log = kaizen.logging.getLogger(self)