def do_depend(builder, pkg_name, role_names,
deps):
"""
Make pkg_name in role_names depend on the contents of deps.
deps is a list of 2-tuples (pkg_name, role_name)
If the role name is None, we depend on the pkg name in the role we're
currently using, so ``do_depend(a, ['b', 'c'], [ ('d', None) ])`` leads
to ``a{b}`` depending on ``d{b}`` and ``a{c}`` depending on ``d{c}``.
If role_names is a string, we will implicitly convert it into the
singleton list [ role_names ].
"""
ruleset = builder.ruleset
if isinstance(role_names, basestring):
r = role_names
role_names = [ r ]
for role_name in role_names:
for (pkg, role) in deps:
if (role is None):
role = role_name
ruleset.add(depend.depend_one(None,
depend.Label(utils.LabelType.Package,
pkg_name, role_name,
utils.LabelTag.PreConfig),
depend.Label(utils.LabelType.Package,
pkg, role,
utils.LabelTag.PostInstalled)))
def do_depend(builder, pkg_name, role_names, deps):
"""
Make pkg_name in role_names depend on the contents of deps.
deps is a list of 2-tuples (pkg_name, role_name)
If the role name is None, we depend on the pkg name in the role we're
currently using, so ``do_depend(a, ['b', 'c'], [ ('d', None) ])`` leads
to ``a{b}`` depending on ``d{b}`` and ``a{c}`` depending on ``d{c}``.
If role_names is a string, we will implicitly convert it into the
singleton list [ role_names ].
"""
ruleset = builder.ruleset
if isinstance(role_names, basestring):
r = role_names
role_names = [r]
for role_name in role_names:
for (pkg, role) in deps:
if (role is None):
role = role_name
ruleset.add(
depend.depend_one(
None,
depend.Label(utils.LabelType.Package, pkg_name, role_name,
utils.LabelTag.PreConfig),
depend.Label(utils.LabelType.Package, pkg, role,
utils.LabelTag.PostInstalled)))
def package_depends_on_checkout(ruleset,
pkg_name,
role_name,
co_name,
action=None):
"""
Make the given package depend on the given checkout
* ruleset - The ruleset to use - builder.ruleset, for example.
* pkg_name - The package which depends.
* role_name - The role which depends. Can be '*' for a wildcard.
* co_name - The checkout which this package and role depends on.
* action - If non-None, specifies an Action to be invoked to get from
the checkout to the package preconfig. If you are a normal (outside
muddle itself) caller, then you will normally leave this None unless you
are doing something deeply weird.
"""
checkout = depend.Label(utils.LabelType.Checkout, co_name, None,
utils.LabelTag.CheckedOut)
preconfig = depend.Label(utils.LabelType.Package, pkg_name, role_name,
utils.LabelTag.PreConfig)
new_rule = depend.Rule(preconfig, action)
new_rule.add(checkout)
ruleset.add(new_rule)
# We can't clean or distclean a package until we've checked out its checkout
# Both are transient, as we don't need to remember we've done them, and
# indeed they should be doable more than once
clean = depend.Label(utils.LabelType.Package,
pkg_name,
role_name,
utils.LabelTag.Clean,
transient=True)
ruleset.add(depend.depend_one(action, clean, checkout))
distclean = depend.Label(utils.LabelType.Package,
pkg_name,
role_name,
utils.LabelTag.DistClean,
transient=True)
ruleset.add(depend.depend_one(action, distclean, checkout))
def package_depends_on_checkout(ruleset, pkg_name, role_name, co_name, action=None):
"""
Make the given package depend on the given checkout
* ruleset - The ruleset to use - builder.ruleset, for example.
* pkg_name - The package which depends.
* role_name - The role which depends. Can be '*' for a wildcard.
* co_name - The checkout which this package and role depends on.
* action - If non-None, specifies an Action to be invoked to get from
the checkout to the package preconfig. If you are a normal (outside
muddle itself) caller, then you will normally leave this None unless you
are doing something deeply weird.
"""
checkout = depend.Label(utils.LabelType.Checkout,
co_name, None,
utils.LabelTag.CheckedOut)
preconfig = depend.Label(utils.LabelType.Package,
pkg_name, role_name,
utils.LabelTag.PreConfig)
new_rule = depend.Rule(preconfig, action)
new_rule.add(checkout)
ruleset.add(new_rule)
# We can't clean or distclean a package until we've checked out its checkout
# Both are transient, as we don't need to remember we've done them, and
# indeed they should be doable more than once
clean = depend.Label(utils.LabelType.Package,
pkg_name, role_name,
utils.LabelTag.Clean,
transient = True)
ruleset.add(depend.depend_one(action, clean, checkout))
distclean = depend.Label(utils.LabelType.Package,
pkg_name, role_name,
utils.LabelTag.DistClean,
transient = True)
ruleset.add(depend.depend_one(action, distclean, checkout))
def depend_across_roles(ruleset, pkg_name, role_names, depends_on_pkgs,
depends_on_role):
"""
Register that pkg_name{role_name}'s preconfig depends on
depends_on_pkg{depends_on_role} having been postinstalled.
"""
for pkg in depends_on_pkgs:
for role_name in role_names:
ruleset.add(
depend.depend_one(
None,
depend.Label(utils.LabelType.Package, pkg_name, role_name,
utils.LabelTag.PreConfig),
depend.Label(utils.LabelType.Package, pkg, depends_on_role,
utils.LabelTag.PostInstalled)))
def depend_across_roles(ruleset, pkg_name, role_names,
depends_on_pkgs, depends_on_role):
"""
Register that pkg_name{role_name}'s preconfig depends on
depends_on_pkg{depends_on_role} having been postinstalled.
"""
for pkg in depends_on_pkgs:
for role_name in role_names:
ruleset.add(depend.depend_one(None,
depend.Label(utils.LabelType.Package,
pkg_name, role_name,
utils.LabelTag.PreConfig),
depend.Label(utils.LabelType.Package,
pkg,
depends_on_role,
utils.LabelTag.PostInstalled)))
def do_depend_label(builder, pkg_name, role_names, label):
"""
Make pkg_name in role_names depend on the given label
If role_names is a string, we will implicitly convert it into the
singleton list [ role_names ].
"""
ruleset = builder.ruleset
if isinstance(role_names, basestring):
r = role_names
role_names = [r]
for role_name in role_names:
ruleset.add(
depend.depend_one(
None,
depend.Label(utils.LabelType.Package, pkg_name, role_name,
utils.LabelTag.PreConfig), label))
def do_depend_label(builder, pkg_name, role_names,
label):
"""
Make pkg_name in role_names depend on the given label
If role_names is a string, we will implicitly convert it into the
singleton list [ role_names ].
"""
ruleset = builder.ruleset
if isinstance(role_names, basestring):
r = role_names
role_names = [ r ]
for role_name in role_names:
ruleset.add(depend.depend_one(None,
depend.Label(utils.LabelType.Package,
pkg_name, role_name,
utils.LabelTag.PreConfig),
label))
def add_package_rules(ruleset, pkg_name, role_name, action):
"""
Add the standard package rules to a ruleset.
"""
depend.depend_chain(
action,
depend.Label(utils.LabelType.Package, pkg_name, role_name,
utils.LabelTag.PreConfig), [
utils.LabelTag.Configured, utils.LabelTag.Built,
utils.LabelTag.Installed, utils.LabelTag.PostInstalled
], ruleset)
# "clean" is transient, since we don't want/need to remember that it
# has been done (doing "clean" more than once is rather requires to
# be harmless)
#
# "clean" used to depend on "preconfig", but this sometimes had strange
# results - for instance, if "preconfig" on A depended on "checked_out"
# of B.
#
# Instead, we will make "clean" depend on "checked_out", and as such this
# is done in package_depends_on_checkout, just as "distclean" always has
# been
if False:
ruleset.add(
depend.depend_one(
action,
depend.Label(utils.LabelType.Package,
pkg_name,
role_name,
utils.LabelTag.Clean,
transient=True),
depend.Label(utils.LabelType.Package,
pkg_name,
role_name,
utils.LabelTag.CheckedOut,
transient=True)))
def add_package_rules(ruleset, pkg_name, role_name, action):
"""
Add the standard package rules to a ruleset.
"""
depend.depend_chain(action,
depend.Label(utils.LabelType.Package,
pkg_name, role_name,
utils.LabelTag.PreConfig),
[ utils.LabelTag.Configured,
utils.LabelTag.Built,
utils.LabelTag.Installed,
utils.LabelTag.PostInstalled ],
ruleset)
# "clean" is transient, since we don't want/need to remember that it
# has been done (doing "clean" more than once is rather requires to
# be harmless)
#
# "clean" used to depend on "preconfig", but this sometimes had strange
# results - for instance, if "preconfig" on A depended on "checked_out"
# of B.
#
# Instead, we will make "clean" depend on "checked_out", and as such this
# is done in package_depends_on_checkout, just as "distclean" always has
# been
if False:
ruleset.add(depend.depend_one(action,
depend.Label(utils.LabelType.Package,
pkg_name, role_name,
utils.LabelTag.Clean,
transient = True),
depend.Label(utils.LabelType.Package,
pkg_name, role_name,
utils.LabelTag.CheckedOut,
transient = True)))
