def _ensureDeclare(self, pkgroot, mprod, flavor, rootdir, productRoot, setups):
flavor = self.eups.flavor
prod = self.eups.findProduct(mprod.product, mprod.version, flavor=flavor)
if prod:
return
repos = self.repos[pkgroot]
if rootdir and not os.path.exists(rootdir):
raise EupsException("%s %s installation not found at %s" % (mprod.product, mprod.version, rootdir))
# make sure we have a table file if we need it
if not rootdir:
rootdir = "none"
if rootdir == "none":
rootdir = "/dev/null"
upsdir = None
tablefile = mprod.tablefile
else:
upsdir = os.path.join(rootdir, "ups")
tablefile = os.path.join(upsdir, "%s.table" % mprod.product)
# Expand that tablefile (adding an exact block)
def expandTableFile(tablefile):
cmd = "\n".join(setups + ["eups expandtable -i --force %s" % tablefile])
try:
server.system(cmd)
except OSError, e:
print >> self.log, e
def __init__(self, pkgroots, options=None, eupsenv=None,
installFlavor=None, distribClasses=None, override=None, allowEmptyPkgroot=False,
verbosity=None, log=sys.stderr):
"""
@param pkgroots the base URLs for the distribution repositories. This
can either be a list or a pipe-delimited ("|")
string.
@param options a dictionary of named options that are used to fine-
tune the behavior of the repositories. These are
passed onto the constructors for the underlying
Reposistory classes.
@param eupsenv an instance of a Eups class containing the Eups
environment to assume
@param installFlavor the desired flavor any install requests
@param distribClasses a dictionary by name of the Distrib classes
to support. This will augmented by those specified
by a server.
@param override a dictionary of server configuration parameters that
should override the configuration received from
each server.
@param allowEmptyPkgroot we are creating a distribution, so it's OK for pkgroot to be empty
@param verbosity if > 0, print status messages; the higher the
number, the more messages that are printed
(default is the value of eupsenv.verbose).
@param log the destination for status messages (default:
sys.stderr)
"""
if isinstance(pkgroots, str):
pkgroots = map(lambda p: p.strip(), pkgroots.split("|"))
if not allowEmptyPkgroot and len(pkgroots) == 0:
raise EupsException("No package servers to query; set -r or $EUPS_PKGROOT")
# the Eups environment
self.eups = eupsenv
if not self.eups:
self.eups = Eups()
self.verbose = verbosity
if self.verbose is None:
self.verbose = self.eups.verbose
self.log = log
if self.log is None:
self.log = sys.stdout
if not distribClasses:
distribClasses = {}
# the list of repository base URLs
self.pkgroots = []
# a lookup of Repository instances by its base URL
self.repos = {}
# the preferred installation flavor
self.flavor = installFlavor
if not self.flavor:
self.flavor = self.eups.flavor
df = DistribFactory(self.eups)
for name in distribClasses.keys():
# note: this will override the server's recommendation
# if we want change this, use:
# if not df.supportsName(name):
# df.register(distribClasses[name], name)
#
df.register(distribClasses[name], name)
for pkgroot in pkgroots:
# if pkgroot == None:
# ds = None
# else:
# ds = ServerConf.makeServer(pkgroot, eupsenv=eupsenv,
# override=override,
# verbosity=self.eups.verbose)
#
try:
dist = Repository(self.eups, pkgroot, options=options,
flavor=installFlavor, distFactory=df,
verbosity=self.eups.verbose)
self.pkgroots += [pkgroot]
self.repos[pkgroot] = dist
except ImportError, e:
msg = "Unable to use server %s: \"%s\"" % (pkgroot, e)
if self.eups.force:
print >> self.log, msg + "; continuing"
else:
raise RuntimeError(msg + ". Remove server from PKGROOT or use force")
repos.distServer.getFileForProduct(mprod.tablefile,
mprod.product,
mprod.version,
flavor)
expandTableFile(tablefile)
tablefile = open(tablefile, "r")
else:
if upsdir and not os.path.exists(upsdir):
os.makedirs(upsdir)
tablefile = \
repos.distServer.getFileForProduct(mprod.tablefile,
mprod.product,
mprod.version, flavor,
filename=tablefile)
if not os.path.exists(tablefile):
raise EupsException("Failed to find table file %s" % tablefile)
expandTableFile(tablefile)
self.eups.declare(mprod.product, mprod.version, rootdir,
eupsPathDir=productRoot, tablefile=tablefile)
def getInstallRoot(self):
"""return the first directory in the eups path that the user can install
stuff into
"""
return findInstallableRoot(self.eups)
def getBuildDirFor(self, productRoot, product, version, options=None,
flavor=None):
"""return a recommended directory to use to build a given product.
In this implementation, the returned path will usually be of the form
def install(self, product, version=None, updateTags=True, alsoTag=None,
depends=DEPS_ALL, noclean=False, noeups=False, options=None,
manifest=None, searchDep=None):
"""
Install a product and all its dependencies.
@param product the name of the product to install
@param version the desired version of the product. This can either
be a version string or an instance of Tag. If
not provided (or None) the most preferred version
will be installed.
@param updateTags when True (default), server-assigned tags will
be updated for this product and all its dependcies
to match those recommended on the server (even if
a product is already installed); if False, tags
will not be changed.
@param alsoTag A list of tags to assign to all installed products
(in addition to server tags). This can either be
a space-delimited list, a list of string names,
a Tag instance, or a list of Tag instances.
@param depends If DEPS_ALL, product and dependencies will be installed
DEPS_NONE, dependencies will not be installed
DEPS_ONLY, only dependencies will be installed,
usefull for developement purpose (before a
setup -r .)
@param noclean If False (default), the build directory will get
cleaned up after a successful install. A True
value prevents this.
@param noeups if False (default), needed products that are already
installed will be skipped over. If True, an
attempt is made to install them anyway. This
allows a product to be installed in the target
install stack even if it is available in another
stack managed by EUPS. Note, however, that if a
needed product is already installed into the target
stack, the installation may fail. Use with caution.
@param options a dictionary of named options that are used to fine-
tune the behavior of this Distrib class. See
discussion above for a description of the options
supported by this implementation; sub-classes may
support different ones.
@param manifest use this manifest (a local file) as the manifest for
the requested product instead of downloading manifest
from the server.
@param searchDep if False, install will be prevented from recursively
looking for dependencies of dependencies listed in
manifests. In this case, it is assumed that a
manifest contains all necessary dependencies. If
True, the distribution identifiers in the manifest
file are ignored and the dependencies will always
be recursively searched for. If None,
the choice to recurse is left up to the server
where the manifest comes from (which usually
defaults to False).
"""
if alsoTag is not None:
if isinstance(alsoTag, str):
alsoTag = [self.eups.tags.getTag(t) for t in alsoTag.split()]
elif isinstance(alsoTag, Tag):
alsoTag = [alsoTag]
pkg = self.findPackage(product, version)
if not pkg:
raise ProductNotFound(product, version,
msg="Product %s %s not found in any package repository" %
(product, version))
(product, version, flavor, pkgroot) = pkg
productRoot = self.getInstallRoot()
if productRoot is None:
raise EupsException("Unable to find writable place to install in EUPS_PATH")
if manifest is not None:
if not manifest or os.path.exists(manifest):
raise EupsException("%s: user-provided manifest not found" %
manifest)
man = Manifest.fromFile(manifest, self.eups,
verbosity=self.eups.verbose-1)
else:
man = self.repos[pkgroot].getManifest(product, version, flavor)
man.remapEntries() # allow user to rewrite entries in the manifest
if product not in [p.product for p in man.getProducts()]:
raise EupsException("You asked to install %s %s but it is not in the manifest\nCheck manifest.remap (see \"eups startup\") and/or increase the verbosity" % (product, version))
self._msgs = {}
self._recursiveInstall(0, man, product, version, flavor, pkgroot,
productRoot, updateTags, alsoTag, options,
depends, noclean, noeups)
def _ensureDeclare(self, pkgroot, mprod, flavor, rootdir, productRoot, setups):
r"""Make sure that the product is installed
\param pkgroot Source of package being installed
\param mprod A eups.distrib.server.Dependency (e.g. with product name and version)
\param flavor Installation flavor
\param rootdir
\param productRoot Element of EUPS_PATH that we are installing into
\param setups Products that are already setup, used in expanding tablefile
May be None to skip expanding tablefile
"""
flavor = self.eups.flavor
prod = self.eups.findProduct(mprod.product, mprod.version, flavor=flavor)
if prod:
return
repos = self.repos[pkgroot]
if rootdir and not os.path.exists(rootdir):
raise EupsException("%s %s installation not found at %s" % (mprod.product, mprod.version, rootdir))
# make sure we have a table file if we need it
if not rootdir:
rootdir = "none"
if rootdir == "none":
rootdir = "/dev/null"
upsdir = None
tablefile = mprod.tablefile
else:
upsdir = os.path.join(rootdir, "ups")
tablefile = os.path.join(upsdir, "%s.table" % mprod.product)
# Expand that tablefile (adding an exact block)
def expandTableFile(tablefile):
cmd = "\n".join(setups + ["eups expandtable -i --force %s" % tablefile])
try:
server.system(cmd)
except OSError as e:
print(e, file=self.log)
if not os.path.exists(tablefile):
if mprod.tablefile == "none":
tablefile = "none"
else:
# retrieve the table file and install it
if rootdir == "/dev/null":
tablefile = \
repos.distServer.getFileForProduct(mprod.tablefile,
mprod.product,
mprod.version,
flavor)
if setups is not None:
expandTableFile(tablefile)
tablefile = open(tablefile, "r")
else:
if upsdir and not os.path.exists(upsdir):
os.makedirs(upsdir)
tablefile = \
repos.distServer.getFileForProduct(mprod.tablefile,
mprod.product,
mprod.version, flavor,
filename=tablefile)
if not os.path.exists(tablefile):
raise EupsException("Failed to find table file %s" % tablefile)
if setups is not None:
expandTableFile(tablefile)
self.eups.declare(mprod.product, mprod.version, rootdir,
eupsPathDir=productRoot, tablefile=tablefile)