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)
