def create_patch_set_mpm(archive_parser, archive):
"""Create an mpm package from a parser holding a patch set archive"""
# header
header = copy.deepcopy(_solaris_header_fields)
header.update(_solaris_patch_set_header_fields)
# package
package = rhn_mpm.MPM_Package()
# basics
p_name = os.path.basename(archive_parser._archive_dir)
header['name'] = "patch-cluster-solaris-" + p_name
readme = archive_parser.direct_read("README")
header['readme'] = readme
if readme is None:
readme = archive_parser.read(p_name + ".README")
assert readme is not None, "Couldn't fine README file for %s" % p_name
# provides fields: date, summary, and description
dct = parse_cluster_readme(readme)
header.update(dct)
# manufactured basics
header['version'] = header['date'].split()[0].replace("-", "")
provide_self(header)
# patch member info
patch_order = archive_parser.read("patch_order")
assert patch_order is not None, "ERROR: no patch_order file in patch cluster"
patches = patch_order.splitlines()
for i in range(0, len(patches)):
patch = patches[i]
name = patch.split('-')
header['patches'].append({'name': "patch-solaris-" + name[0],
'version': name[1], 'patch_order': i+1})
# arch info is put into each patch's readme, so parse the first one
if i == 0:
patch_readme = archive_parser.read(os.path.join(patch, "README." + patch))
dct = parse_patch_readme(patch_readme)
header['arch'] = dct['target_arch'] + '-' + header['arch']
# payload: creates a dummy file object out of an empty string
# package.payload_stream = StringIO.StringIO()
# XXX kludey hack to get the client operations working for patch clusters
header['package_name'] = os.path.basename(archive)
header['package_size'] = os.path.getsize(archive)
package.payload_stream = open(archive)
# signature and encoding
header['sigmd5'] = md5sum_for_stream(package.payload_stream)
package.header = rhn_mpm.MPM_Header(header)
return package
def package_from_stream(stream, packaging):
if packaging == 'deb':
from spacewalk.common import rhn_deb
a_pkg = rhn_deb.DEB_Package(stream)
elif packaging == 'rpm':
from spacewalk.common import rhn_rpm
a_pkg = rhn_rpm.RPM_Package(stream)
elif packaging == 'mpm':
from spacewalk.common import rhn_mpm
a_pkg = rhn_mpm.MPM_Package(stream)
else:
a_pkg = None
return a_pkg
def create_pkg_mpm(archive_parser, prefix=""):
"""create a pacakge mpm from an archive parser holding the package
archive"""
# header
header = copy.deepcopy(_solaris_header_fields)
# package
package = rhn_mpm.MPM_Package()
# basics: provides name, version, release, package_group, arch, etc
pkginfo_str = archive_parser.read(os.path.join(prefix, "pkginfo"))
header['pkginfo'] = pkginfo_str
dct = parse_pkginfo(pkginfo_str)
header.update(dct)
header['release'] = compose_pstamp_and_release(header)
# bug 159323: pkgmap
header['pkgmap'] = archive_parser.read(os.path.join(prefix,
"pkgmap")) or ""
# dependency info, if it exists
dep_file = os.path.join(prefix, "install/depend")
if archive_parser.contains(dep_file):
dep_str = archive_parser.read(dep_file)
dct = parse_depends(dep_str)
header.update(dct)
# Provides ourself after the header has been updated with the dependency
# info (if at all). This will prevent our own provides from being
# overwritten.
provide_self(header)
# payload
cpio_file = archive_parser.cpio(prefix)
_temp_files.append(cpio_file)
header['package_name'] = os.path.basename(cpio_file)
header['package_size'] = os.path.getsize(cpio_file)
package.payload_stream = open(cpio_file)
# signature and encoding
header['sigmd5'] = md5sum_for_stream(package.payload_stream)
package.header = rhn_mpm.MPM_Header(header)
return package
def rpm_to_mpm(header, file_stream):
tag_map = {
'package_group': 'group',
'rpm_version': 'rpmversion',
'payload_size': 'archivesize',
'payload_format': 'payloadformat',
'build_host': 'buildhost',
'build_time': 'buildtime',
'source_rpm': 'sourcerpm',
}
tags = [
'name',
'epoch',
'version',
'release',
'arch',
'description',
'summary',
'license',
'package_group',
'rpm_version',
'payload_size',
'payload_format',
'build_host',
'build_time',
'cookie',
'vendor',
'source_rpm',
'sigmd5',
'sigpgp',
'siggpg',
'sigsize',
]
result = {}
for t in tags:
tt = tag_map.get(t, t)
result[t] = header[tt]
# Add files
result['files'] = _extract_files(header)
# Dependency
result['provides'] = _extract_rpm_requires(header)
result['requires'] = _extract_rpm_provides(header)
result['conflicts'] = _extract_rpm_conflicts(header)
result['obsoletes'] = _extract_rpm_obsoletes(header)
result['changelog'] = _extract_rpm_changelog(header)
# md5sum, package_size
file_stream.seek(0, 2)
file_size = file_stream.tell()
result['package_size'] = file_size
is_source = 0
if header.is_source:
is_source = 1
result['is_source'] = is_source
result['package_type'] = 'rpm'
h = rhn_mpm.MPM_Header(result)
p = rhn_mpm.MPM_Package()
p.header = h
p.payload_stream = file_stream
return p
def create_patch_mpm(archive_parser, prefix="", archive=""):
"""Create an mpm package from a parser holding a patch archive"""
# pylint: disable=R0915
# have to have one or the other
assert prefix or archive
# header
header = copy.deepcopy(_solaris_header_fields)
header.update(_solaris_patch_header_fields)
# package
package = rhn_mpm.MPM_Package()
# basics
p_name = os.path.basename(prefix or archive_parser._archive_dir)
p_array = p_name.split("-")
header['name'] = "patch-solaris-" + p_array[0]
header['version'] = p_array[1]
provide_self(header)
readme = archive_parser.read(os.path.join(prefix, "README.%s" % p_name))
header['readme'] = readme
# provides fields: date, summary, description, solaris_rel,
# sunos_rel, target_arch
dct = parse_patch_readme(readme)
header['arch'] = dct['target_arch'] + '-' + header['arch']
header.update(dct)
# provides fields: intonly, requires, conflicts, obsoletes
patchinfo_file = os.path.join(prefix, 'patchinfo')
if archive_parser.contains(patchinfo_file):
patchinfo = archive_parser.read(patchinfo_file)
dct = parse_patchinfo(patchinfo)
header.update(dct)
# a patch can patch multiple packages
patch_path = prefix
patch_path_with_subdir = os.path.join('patches/', patch_path)
# recent format has files in patches subdir
if os.path.isdir(os.path.join(archive_parser._archive_dir, patch_path_with_subdir)):
patch_path = patch_path_with_subdir
pkgs, _dummy = archive_parser.list(patch_path)
for pkg in pkgs:
pkginfo_file = os.path.join(prefix, pkg, 'pkginfo')
# directory doesn't actually correspond to a patch
if not archive_parser.contains(pkginfo_file):
continue
pkginfo = archive_parser.read(pkginfo_file)
dct = parse_patch_pkginfo(pkginfo)
if dct['package']:
header['packages'].append(dct['package'])
# dependency info is included in the package info
if dct['obsoletes']:
header['obsoletes'] += dct['obsoletes']
if dct['requires']:
header['requires'] += dct['requires']
if dct['conflicts']:
header['conflicts'] += dct['conflicts']
header['obsoletes'] = _unique_list_of_dicts(header['obsoletes'])
header['provides'].extend(header['obsoletes'])
header['requires'] = _unique_list_of_dicts(header['requires'])
header['conflicts'] = _unique_list_of_dicts(header['conflicts'])
# payload
if archive:
header['package_name'] = os.path.basename(archive)
header['package_size'] = os.path.getsize(archive)
package.payload_stream = open(archive)
else:
zip_file = archive_parser.zip(patch_path)
_temp_files.append(zip_file)
header['package_name'] = os.path.basename(zip_file)
header['package_size'] = os.path.getsize(zip_file)
package.payload_stream = open(zip_file)
# signature and encoding
header['sigmd5'] = md5sum_for_stream(package.payload_stream)
package.header = rhn_mpm.MPM_Header(header)
return package
