def from_name(name, ignore_dep = None):
packagedb = pisi.db.packagedb.PackageDB()
# download package and return an installer object
# find package in repository
repo = packagedb.which_repo(name)
if repo:
repodb = pisi.db.repodb.RepoDB()
ctx.ui.info(_("Package %s found in repository %s") % (name, repo))
repo = repodb.get_repo(repo)
pkg = packagedb.get_package(name)
delta = None
installdb = pisi.db.installdb.InstallDB()
# Package is installed. This is an upgrade. Check delta.
if installdb.has_package(pkg.name):
(version, release, build, distro, distro_release) = installdb.get_version_and_distro_release(pkg.name)
# pisi distro upgrade should not use delta support
if distro == pkg.distribution and distro_release == pkg.distributionRelease:
delta = pkg.get_delta(release)
ignore_delta = ctx.config.values.general.ignore_delta
# If delta exists than use the delta uri.
if delta and not ignore_delta:
pkg_uri = delta.packageURI
pkg_hash = delta.packageHash
else:
pkg_uri = pkg.packageURI
pkg_hash = pkg.packageHash
uri = pisi.uri.URI(pkg_uri)
if uri.is_absolute_path():
pkg_path = str(pkg_uri)
else:
pkg_path = os.path.join(os.path.dirname(repo.indexuri.get_uri()),
str(uri.path()))
ctx.ui.info(_("Package URI: %s") % pkg_path, verbose=True)
# Bug 4113
cached_file = pisi.package.Package.is_cached(pkg_path)
if cached_file and util.sha1_file(cached_file) != pkg_hash:
os.unlink(cached_file)
cached_file = None
install_op = Install(pkg_path, ignore_dep)
# Bug 4113
if not cached_file:
downloaded_file = install_op.package.filepath
if pisi.util.sha1_file(downloaded_file) != pkg_hash:
raise pisi.Error(_("Download Error: Package does not match the repository package."))
return install_op
else:
raise Error(_("Package %s not found in any active repository.") % name)
def calculate_download_sizes(order):
total_size = cached_size = 0
installdb = pisilinux.db.installdb.InstallDB()
packagedb = pisilinux.db.packagedb.PackageDB()
try:
cached_packages_dir = ctx.config.cached_packages_dir()
except OSError:
# happens when cached_packages_dir tried to be created by an unpriviledged user
cached_packages_dir = None
for pkg in [packagedb.get_package(name) for name in order]:
delta = None
if installdb.has_package(pkg.name):
(version, release, build, distro, distro_release) = installdb.get_version_and_distro_release(pkg.name)
# pisilinux distro upgrade should not use delta support
if distro == pkg.distribution and distro_release == pkg.distributionRelease:
delta = pkg.get_delta(release)
ignore_delta = ctx.config.values.general.ignore_delta
if delta and not ignore_delta:
fn = os.path.basename(delta.packageURI)
pkg_hash = delta.packageHash
pkg_size = delta.packageSize
else:
fn = os.path.basename(pkg.packageURI)
pkg_hash = pkg.packageHash
pkg_size = pkg.packageSize
if cached_packages_dir:
path = util.join_path(cached_packages_dir, fn)
# check the file and sha1sum to be sure it _is_ the cached package
if os.path.exists(path) and util.sha1_file(path) == pkg_hash:
cached_size += pkg_size
elif os.path.exists("%s.part" % path):
cached_size += os.stat("%s.part" % path).st_size
total_size += pkg_size
ctx.ui.notify(ui.cached, total=total_size, cached=cached_size)
return total_size, cached_size
def add_package(params):
try:
path, deltas, repo_uri = params
ctx.ui.info("%-80.80s\r" % (_('Adding package to index: %s') %
os.path.basename(path)), noln = True)
package = pisi.package.Package(path, 'r')
md = package.get_metadata()
md.package.packageSize = int(os.path.getsize(path))
md.package.packageHash = util.sha1_file(path)
if ctx.config.options and ctx.config.options.absolute_urls:
md.package.packageURI = os.path.realpath(path)
else:
md.package.packageURI = util.removepathprefix(repo_uri, path)
# check package semantics
errs = md.errors()
if md.errors():
ctx.ui.info("")
ctx.ui.error(_('Package %s: metadata corrupt, skipping...') % md.package.name)
ctx.ui.error(str(Error(*errs)))
else:
# No need to carry these with index (#3965)
md.package.files = None
md.package.additionalFiles = None
if md.package.name in deltas:
name, version, release, distro_id, arch = \
util.split_package_filename(path)
for delta_path in deltas[md.package.name]:
src_release, dst_release, delta_distro_id, delta_arch = \
util.split_delta_package_filename(delta_path)[1:]
# Add only delta to latest build of the package
if dst_release != md.package.release or \
(delta_distro_id, delta_arch) != (distro_id, arch):
continue
delta = metadata.Delta()
delta.packageURI = util.removepathprefix(repo_uri, delta_path)
delta.packageSize = int(os.path.getsize(delta_path))
delta.packageHash = util.sha1_file(delta_path)
delta.releaseFrom = src_release
md.package.deltaPackages.append(delta)
return md.package
except KeyboardInterrupt:
# Handle KeyboardInterrupt exception to prevent ugly backtrace of all
# worker processes and propagate the exception to main process.
#
# Probably it's better to use just 'raise' here, but multiprocessing
# module has some bugs about that: (python#8296, python#9205 and
# python#9207 )
#
# For now, worker processes do not propagate exceptions other than
# Exception (like KeyboardInterrupt), so we have to manually propagate
# KeyboardInterrupt exception as an Exception.
raise Exception
def build_packages(self):
"""Build each package defined in PSPEC file. After this process there
will be .pisilinux files hanging around, AS INTENDED ;)"""
doc_ptrn = re.compile(ctx.const.doc_package_end)
self.fetch_component() # bug 856
# Operations and filters for package files
self.file_actions()
if ctx.get_option("create_static"):
obj = self.generate_static_package_object()
if obj:
self.spec.packages.append(obj)
if ctx.config.values.build.generatedebug:
debug_packages = []
for package in self.spec.packages:
if "noDebug" in package.buildFlags:
continue
obj = self.generate_debug_package_object(package)
if obj:
debug_packages.append(obj)
if debug_packages:
self.spec.packages.extend(debug_packages)
install_dir = self.pkg_install_dir()
# Store additional files
c = os.getcwd()
os.chdir(self.specdir)
for package in self.spec.packages:
for afile in package.additionalFiles:
src = os.path.join(ctx.const.files_dir, afile.filename)
dest = os.path.join(install_dir + os.path.dirname(afile.target), os.path.basename(afile.target))
util.copy_file(src, dest)
if afile.permission:
# mode is octal!
os.chmod(dest, int(afile.permission, 8))
if afile.owner:
try:
os.chown(dest, pwd.getpwnam(afile.owner)[2], -1)
except KeyError:
ctx.ui.warning(_("No user named '%s' found " "on the system") % afile.owner)
if afile.group:
try:
os.chown(dest, -1, grp.getgrnam(afile.group)[2])
except KeyError:
ctx.ui.warning(_("No group named '%s' found " "on the system") % afile.group)
os.chdir(c)
# Show the files those are not collected from the install dir
abandoned_files = self.get_abandoned_files()
if abandoned_files:
ctx.ui.error(_("There are abandoned files " "under the install dir (%s):") % install_dir)
for f in abandoned_files:
ctx.ui.info(" - %s" % f)
raise AbandonedFilesException
for package in self.spec.packages:
# removing "farce" in specfile.py:SpecFile.override_tags
# this block of code came here... SpecFile should never
# ever ruin the generated PSPEC file. If build process
# needs this, we should do it in here... (bug: #3773)
if not package.summary:
package.summary = self.spec.source.summary
if not package.description:
package.description = self.spec.source.description
if not package.partOf:
if package.name.endswith(ctx.const.devel_package_end):
if self.spec.source.partOf in ctx.const.assign_to_system_devel:
package.partOf = ctx.const.system_devel_component
else:
package.partOf = ctx.const.devels_component
elif re.search(doc_ptrn, package.name):
package.partOf = ctx.const.docs_component
else:
package.partOf = self.spec.source.partOf
if not package.license:
package.license = self.spec.source.license
if not package.icon:
package.icon = self.spec.source.icon
self.gen_files_xml(package)
if not self.files.list:
if not package.debug_package:
ctx.ui.warning(_("Ignoring empty package %s") % package.name)
continue
ctx.ui.action(_("Building package: %s") % package.name)
self.gen_metadata_xml(package)
name = self.package_filename(self.metadata.package)
outdir = ctx.get_option("output_dir")
if outdir:
name = util.join_path(outdir, name)
name = os.path.normpath(name)
if package.debug_package:
self.new_debug_packages.append(name)
else:
self.new_packages.append(name)
ctx.ui.info(_("Creating %s...") % name)
pkg = pisilinux.package.Package(name, "w", format=self.target_package_format, tmp_dir=self.pkg_dir())
# add comar files to package
os.chdir(self.specdir)
for pcomar in package.providesComar:
fname = util.join_path(ctx.const.comar_dir, pcomar.script)
pkg.add_to_package(fname)
# add xmls and files
os.chdir(self.pkg_dir())
pkg.add_files_xml(ctx.const.files_xml)
# Sort the files in-place according to their path for an ordered
# tarfile layout which dramatically improves the compression
# performance of lzma.
pkg.files.list.sort(key=lambda x: x.path)
for finfo in pkg.files.list:
orgname = util.join_path("install", finfo.path)
if package.debug_package:
orgname = util.join_path("debug", finfo.path)
pkg.add_to_install(orgname, finfo.path)
self.metadata.package.installTarHash = util.sha1_file("%s/install.tar.xz" % self.pkg_dir())
self.metadata.write(util.join_path(self.pkg_dir(), ctx.const.metadata_xml))
pkg.add_metadata_xml(ctx.const.metadata_xml)
os.chdir(c)
# FIXME Remove this hack
pkg.metadata.package.debug_package = package.debug_package
if "noDelta" not in package.buildFlags:
delta_packages = self.build_delta_packages(pkg)
else:
delta_packages = []
self.delta_map[name] = delta_packages
pkg.close()
self.set_state("buildpackages")
if ctx.config.values.general.autoclean is True:
ctx.ui.info(_("Cleaning build directory..."))
util.clean_dir(self.pkg_dir())
else:
ctx.ui.info(_("Keeping build directory"))
# reset environment variables after build. this one is for
# buildfarm actually. buildfarm re-inits pisilinux for each build
# and left environment variables go directly into initial dict
# making actionsapi.variables.exportFlags() useless...
os.environ.clear()
os.environ.update(ctx.config.environ)
