Beispiel #1
0
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)
Beispiel #2
0
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)
Beispiel #3
0
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)
Beispiel #4
0
def build_with_helper(builder,
                      helpers,
                      pkg_name,
                      checkout,
                      roles,
                      makefileName=None,
                      co_dir=None,
                      repoRelative=None,
                      rev=None):
    """
    Builds a package called 'pkg_name' from a makefile in a helpers checkout
    called 'helpers', involving the use of the checkout 'checkout',
    which is a relative checkout with optional second level name
    co_dir, repo relative name repoRelative, and revision rev.

    In other words, declares that 'pkg_name' in the given 'roles' will be built
    with the Makefile called:

        <helpers>/<makefileName>

    If 'co_dir' is None, this will be checked out using
    checkouts.simple.relative(), otherwise it will be checked out using
    checkouts.twolevel.relative(). The 'co_dir', 'repoRelative' and 'rev'
    arguments will be used in the obvious ways.
    """

    if (makefileName is None):
        makefileName = os.path.join(pkg_name, "Makefile.muddle")

    make.medium(builder,
                name=pkg_name,
                roles=roles,
                checkout="helpers",
                makefileName=makefileName,
                simpleCheckout=False)

    # Make sure we actually check out ..
    if (co_dir is None):
        co_simple.relative(builder, checkout, repoRelative, rev)
    else:
        co_twolevel.relative(builder,
                             co_dir=co_dir,
                             co_name=checkout,
                             repo_relative=repoRelative,
                             rev=rev)

    # Now depend on any additional checkouts ..
    for r in roles:
        pkg.package_depends_on_checkout(builder.ruleset, pkg_name, r, checkout)
Beispiel #5
0
def build_with_helper(builder, helpers, pkg_name, checkout, roles,
                      makefileName = None,
                      co_dir = None,
                      repoRelative = None,
                      rev = None):
    """
    Builds a package called 'pkg_name' from a makefile in a helpers checkout
    called 'helpers', involving the use of the checkout 'checkout',
    which is a relative checkout with optional second level name
    co_dir, repo relative name repoRelative, and revision rev.

    In other words, declares that 'pkg_name' in the given 'roles' will be built
    with the Makefile called:

        <helpers>/<makefileName>

    If 'co_dir' is None, this will be checked out using
    checkouts.simple.relative(), otherwise it will be checked out using
    checkouts.twolevel.relative(). The 'co_dir', 'repoRelative' and 'rev'
    arguments will be used in the obvious ways.
    """

    if (makefileName is None):
        makefileName = os.path.join(pkg_name, "Makefile.muddle")

    make.medium(builder,
                name = pkg_name,
                roles = roles,
                checkout = "helpers",
                makefileName = makefileName,
                simpleCheckout = False)

    # Make sure we actually check out ..
    if (co_dir is None):
        co_simple.relative(builder, checkout, repoRelative, rev)
    else:
        co_twolevel.relative(builder,
                             co_dir = co_dir,
                             co_name = checkout,
                             repo_relative = repoRelative,
                             rev = rev)

    # Now depend on any additional checkouts ..
    for r in roles:
        pkg.package_depends_on_checkout(builder.ruleset,
                                        pkg_name,
                                        r,
                                        checkout)
Beispiel #6
0
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)
Beispiel #7
0
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)
Beispiel #8
0
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)
Beispiel #9
0
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)
Beispiel #10
0
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)