def create(builder, name, role, pkgs_and_roles, custom_depmod=None, subdir="/lib/modules"): """ Create a depmod_merge . It will depend on each of the mentioned packages. pkgs is a list of (pkg, role) pairs. We return the depmod_merge we've created. """ action = MergeDepModBuilder(name, role, custom_depmod) pkg.add_package_rules(builder.ruleset, name, role, action) pkg.do_depend(builder, name, [role], pkgs_and_roles) for (pname, role) in pkgs_and_roles: lbl = depend.Label(utils.LabelType.Package, pname, role, utils.LabelTag.PostInstalled) action.add_label(lbl, subdir) return action
def simple(builder, name, role, checkout, rev=None, branch=None, simpleCheckout=False, config=True, perRoleMakefiles=False, makefileName=DEFAULT_MAKEFILE_NAME): """ Build a package controlled by our simplified C/C++ make rules, called name with role role from the sources in checkout checkout. * simpleCheckout - If True, register the checkout too. * config - If True, we have make config. If false, we don't. * perRoleMakefiles - If True, we run 'make -f Makefile.<rolename>' instead of just make. """ if (simpleCheckout): simple_checkouts.relative(builder, checkout, rev=rev, branch=branch) the_pkg = CxxBuilder(name, role, checkout, config=config, perRoleMakefiles=perRoleMakefiles, makefileName=makefileName) # Add the standard dependencies .. pkg.add_package_rules(builder.ruleset, name, role, the_pkg) # .. and make us depend on the checkout. pkg.package_depends_on_checkout(builder.ruleset, name, role, checkout, the_pkg)
def create(builder, name, role, pkgs_and_roles, custom_depmod = None, subdir = "/lib/modules"): """ Create a depmod_merge . It will depend on each of the mentioned packages. pkgs is a list of (pkg, role) pairs. We return the depmod_merge we've created. """ action = MergeDepModBuilder(name, role, custom_depmod) pkg.add_package_rules(builder.ruleset, name, role, action) pkg.do_depend(builder, name, [role], pkgs_and_roles) for (pname, role) in pkgs_and_roles: lbl = depend.Label(utils.LabelType.Package, pname, role, utils.LabelTag.PostInstalled) action.add_label(lbl, subdir) return action
def simple(builder, name, role, apt_pkgs, os_version=None): """ Construct an apt-alt package in the given role with the given apt_pkgs, which are dictionaries: (name : 'name', min-version : , exact-version : , max-version: , repo : ) """ the_pkg = AptAltBuilder(name, role, apt_pkgs, os_version) pkg.add_package_rules(builder.ruleset, name, role, the_pkg)
def expanding_package(builder, name, archive_dir, role, co_name, co_dir, makefile=DEFAULT_MAKEFILE_NAME, deps=None, archive_file=None, archive_ext='.tar.bz2',): """Specify how to expand and build an archive file. As normal, 'name' is the package name, 'role' is the role to build it in, 'co_name' is the name of the checkout, and 'co_dir' is the directory in which that lives. We expect to unpack an archive <co_dir>/<co_name>/<archive_dir><archive_ext> into $(MUDDLE_OBJ)/<archive_dir>. (NB: if the archive file does not expand into a directory of the obvious name, you can specify the archive file name separately, using 'archive_file'). So, for instance, all of our X11 "stuff" lives in checkout "X11R7.5" which is put into directory "x11" -- i.e., "src/X11/X11R7.5". That lets us keep stuff together in the repository, without leading to a great many packages that are of no direct interest to anyone else. Within that we then have various muddle makefiles, and a set of .tar.bz archive files. 1. The archive file expands into a directory called 'archive_dir' 2. It is assumed that the archive file is named 'archive_dir' + 'archive_ext'. If this is not so, then specify 'archive_file' (and/or 'archive_ext') appropriately. This function is used to say: take the named archive file, use package name 'name', unpack the archive file into $(MUDDLE_OBJ_OBJ), and build it using the named muddle makefile. This allows various things to be build with the same makefile, which is useful for (for instance) X11 proto[type] archives. Note that in $(MUDDLE_OBJ), 'obj' (i.e., $(MUDDLE_OBJ_OBJ)) will be a soft link to the expanded archive directory. """ if archive_file is None: archive_file = archive_dir + archive_ext # Define how to build our package dep = ExpandingMakeBuilder(name, role, co_name, archive_file, archive_dir, makefile) pkg.add_package_rules(builder.ruleset, name, role, dep) # It depends on the checkout pkg.package_depends_on_checkout(builder.ruleset, name, role, co_name) # And maybe on other packages if deps: pkg.do_depend(builder, name, [role], deps)
def simple(builder, coName, name, roles, depends_on=[], pkgFile=None, debName=None, instrFile=None, postInstallMakefile=None, isDev=False, nonDevCoName=None, nonDevPkgFile=None): """ Build a package called 'name' from co_name / pkg_file with an instruction file called instr_file. 'name' is the name of the muddle package and of the debian package. if you want them different, set deb_name to something other than None. Set isDev to True for a dev package, False for an ordinary binary package. Dev packages are installed into the object directory where MUDDLE_INC_DIRS etc. expects to look for them. Actual packages are installed into the installation directory where they will be transported to the target system. """ if (debName is None): debName = name if (pkgFile is None): pkgFile = debName for r in roles: if isDev: dep = DebDevAction(name, r, coName, debName, pkgFile, instrFile, postInstallMakefile, nonDevCoName=nonDevCoName, nonDevPkgFile=nonDevPkgFile) else: dep = DebAction(name, r, coName, debName, pkgFile, instrFile, postInstallMakefile) pkg.add_package_rules(builder.ruleset, name, r, dep) # We should probably depend on the checkout .. . pkg.package_depends_on_checkout(builder.ruleset, name, r, coName, dep) # .. and some other packages. Y'know, because we can .. pkg.package_depends_on_packages(builder.ruleset, name, r, utils.LabelTag.PreConfig, depends_on)
def simple(builder, name, roles, filename = "/version.xml", swname = None, version = None, build = None, withDate = True, withUser = True, withMachine = True): for r in roles: the_pkg = VersionBuilder(name, r, filename, swname, version, build, withDate, withUser, withMachine) pkg.add_package_rules(builder.ruleset, name, r, the_pkg)
def simple(builder, name, role, script_name, deployments = [ ], writeSetvarsSh = True, writeSetvarsPy = False): """ Build an init script for the given role. """ the_pkg = InitScriptBuilder(name, role, script_name, deployments, writeSetvarsSh = writeSetvarsSh, writeSetvarsPy = writeSetvarsPy) pkg.add_package_rules(builder.ruleset, name, role, the_pkg) setup_default_env(builder, get_env(builder, name, role))
def simple(builder, name, roles, filename="/version.xml", swname=None, version=None, build=None, withDate=True, withUser=True, withMachine=True): for r in roles: the_pkg = VersionBuilder(name, r, filename, swname, version, build, withDate, withUser, withMachine) pkg.add_package_rules(builder.ruleset, name, r, the_pkg)
def simple(builder, name, role, checkout, rev=None, branch=None, simpleCheckout=False, config=True, perRoleMakefiles=False, makefileName=DEFAULT_MAKEFILE_NAME, usesAutoconf=False, rewriteAutoconf=False, execRelPath=None): """ Build a package controlled by make, called name with role role from the sources in checkout checkout. * simpleCheckout - If True, register the checkout too. * config - If True, we have make config. If false, we don't. * perRoleMakefiles - If True, we run 'make -f Makefile.<rolename>' instead of just make. * usesAutoconf - If True, this package is given access to .la and .pc files from things it depends on. * rewriteAutoconf - If True, we will rewrite .la and .pc files in the output directory so that packages which use autoconf continue to depend correctly. Intended for use with the MUDDLE_PKGCONFIG_DIRS environment variable. * execRelPath - Where, relative to the object directory, do we find binaries for this package? """ if (simpleCheckout): simple_checkouts.relative(builder, checkout, rev=rev, branch=branch) the_pkg = MakeBuilder(name, role, checkout, config=config, perRoleMakefiles=perRoleMakefiles, makefileName=makefileName, usesAutoconf=usesAutoconf, rewriteAutoconf=rewriteAutoconf, execRelPath=execRelPath) # Add the standard dependencies .. pkg.add_package_rules(builder.ruleset, name, role, the_pkg) # .. and make us depend on the checkout. pkg.package_depends_on_checkout(builder.ruleset, name, role, checkout, the_pkg)
def simple(builder, coName, name, roles, depends_on = [ ], pkgFile = None, debName = None, instrFile = None, postInstallMakefile = None, isDev = False, nonDevCoName = None, nonDevPkgFile = None): """ Build a package called 'name' from co_name / pkg_file with an instruction file called instr_file. 'name' is the name of the muddle package and of the debian package. if you want them different, set deb_name to something other than None. Set isDev to True for a dev package, False for an ordinary binary package. Dev packages are installed into the object directory where MUDDLE_INC_DIRS etc. expects to look for them. Actual packages are installed into the installation directory where they will be transported to the target system. """ if (debName is None): debName = name if (pkgFile is None): pkgFile = debName for r in roles: if isDev: dep = DebDevAction(name, r, coName, debName, pkgFile, instrFile, postInstallMakefile, nonDevCoName = nonDevCoName, nonDevPkgFile = nonDevPkgFile) else: dep = DebAction(name, r, coName, debName, pkgFile, instrFile, postInstallMakefile) pkg.add_package_rules(builder.ruleset, name, r, dep) # We should probably depend on the checkout .. . pkg.package_depends_on_checkout(builder.ruleset, name, r, coName, dep) # .. and some other packages. Y'know, because we can .. pkg.package_depends_on_packages(builder.ruleset, name, r, utils.LabelTag.PreConfig, depends_on)
def simple(builder, name, role, checkout, rev = None, branch = None, simpleCheckout = False, config = True, perRoleMakefiles = False, makefileName = DEFAULT_MAKEFILE_NAME): """ Build a package controlled by our simplified C/C++ make rules, called name with role role from the sources in checkout checkout. * simpleCheckout - If True, register the checkout too. * config - If True, we have make config. If false, we don't. * perRoleMakefiles - If True, we run 'make -f Makefile.<rolename>' instead of just make. """ if (simpleCheckout): simple_checkouts.relative(builder, checkout, rev=rev, branch=branch) the_pkg = CxxBuilder(name, role, checkout, config = config, perRoleMakefiles = perRoleMakefiles, makefileName = makefileName) # Add the standard dependencies .. pkg.add_package_rules(builder.ruleset, name, role, the_pkg) # .. and make us depend on the checkout. pkg.package_depends_on_checkout(builder.ruleset, name, role, checkout, the_pkg)
def simple(builder, name, role, checkout, rev=None, branch=None, simpleCheckout = False, config = True, perRoleMakefiles = False, makefileName = DEFAULT_MAKEFILE_NAME, usesAutoconf = False, rewriteAutoconf = False, execRelPath = None): """ Build a package controlled by make, called name with role role from the sources in checkout checkout. * simpleCheckout - If True, register the checkout too. * config - If True, we have make config. If false, we don't. * perRoleMakefiles - If True, we run 'make -f Makefile.<rolename>' instead of just make. * usesAutoconf - If True, this package is given access to .la and .pc files from things it depends on. * rewriteAutoconf - If True, we will rewrite .la and .pc files in the output directory so that packages which use autoconf continue to depend correctly. Intended for use with the MUDDLE_PKGCONFIG_DIRS environment variable. * execRelPath - Where, relative to the object directory, do we find binaries for this package? """ if (simpleCheckout): simple_checkouts.relative(builder, checkout, rev=rev, branch=branch) the_pkg = MakeBuilder(name, role, checkout, config = config, perRoleMakefiles = perRoleMakefiles, makefileName = makefileName, usesAutoconf = usesAutoconf, rewriteAutoconf = rewriteAutoconf, execRelPath = execRelPath) # Add the standard dependencies .. pkg.add_package_rules(builder.ruleset, name, role, the_pkg) # .. and make us depend on the checkout. pkg.package_depends_on_checkout(builder.ruleset, name, role, checkout, the_pkg)
def simple(builder, name, role, apt_pkgs, os_version=None): """ Construct an apt-get package in the given role with the given apt_pkgs. Note that apt_pkgs can be an OS package name or a Choice - see the documentation for AptGetBuilder for more details. For instance (note: not a real example - the dependencies don't make sense!):: from muddled.utils import Choice from muddled.pkgs import aptget aptget.simple(builder, "host_packages", "host_environment", [ "gcc-multilib", "g++-multilib", "lib32ncurses5-dev", "lib32z1-dev", "bison", "flex", "gperf", "libx11-dev", # On Ubuntu 11 or 12, choose icedtea-7, otherwise icedtea-6 Choice([ ("ubuntu 1[12].*", "icedtea-7-jre"), ("ubuntu *", "icedtea-6-jre") ]), # On Ubuntu 10 or later, use libgtiff5 # On Ubuntu 3 through 9, use libgtiff4 # Otherwise, just don't try to use libgtiff Choice([ ("ubuntu 1?", "libgtiff5"), ("ubuntu [3456789]", "libgtiff4"), None ]) ]) """ the_pkg = AptGetBuilder(name, role, apt_pkgs, os_version) pkg.add_package_rules(builder.ruleset, name, role, the_pkg)
def expanding_package( builder, name, archive_dir, role, co_name, co_dir, makefile=DEFAULT_MAKEFILE_NAME, deps=None, archive_file=None, archive_ext='.tar.bz2', ): """Specify how to expand and build an archive file. As normal, 'name' is the package name, 'role' is the role to build it in, 'co_name' is the name of the checkout, and 'co_dir' is the directory in which that lives. We expect to unpack an archive <co_dir>/<co_name>/<archive_dir><archive_ext> into $(MUDDLE_OBJ)/<archive_dir>. (NB: if the archive file does not expand into a directory of the obvious name, you can specify the archive file name separately, using 'archive_file'). So, for instance, all of our X11 "stuff" lives in checkout "X11R7.5" which is put into directory "x11" -- i.e., "src/X11/X11R7.5". That lets us keep stuff together in the repository, without leading to a great many packages that are of no direct interest to anyone else. Within that we then have various muddle makefiles, and a set of .tar.bz archive files. 1. The archive file expands into a directory called 'archive_dir' 2. It is assumed that the archive file is named 'archive_dir' + 'archive_ext'. If this is not so, then specify 'archive_file' (and/or 'archive_ext') appropriately. This function is used to say: take the named archive file, use package name 'name', unpack the archive file into $(MUDDLE_OBJ_OBJ), and build it using the named muddle makefile. This allows various things to be build with the same makefile, which is useful for (for instance) X11 proto[type] archives. Note that in $(MUDDLE_OBJ), 'obj' (i.e., $(MUDDLE_OBJ_OBJ)) will be a soft link to the expanded archive directory. """ if archive_file is None: archive_file = archive_dir + archive_ext # Define how to build our package dep = ExpandingMakeBuilder(name, role, co_name, archive_file, archive_dir, makefile) pkg.add_package_rules(builder.ruleset, name, role, dep) # It depends on the checkout pkg.package_depends_on_checkout(builder.ruleset, name, role, co_name) # And maybe on other packages if deps: pkg.do_depend(builder, name, [role], deps)