blob: 9a836b6a2cad995eae0e85d78808b78c5c823d96 [file] [log] [blame] [edit]
"""
Functions to handle software packages. The functions covered here aim to be
generic, with implementations that deal with different package managers, such
as dpkg and rpm.
"""
__author__ = 'lucasmr@br.ibm.com (Lucas Meneghel Rodrigues)'
import os, re
from autotest_lib.client.bin import os_dep, utils
from autotest_lib.client.common_lib import error
# As more package methods are implemented, this list grows up
KNOWN_PACKAGE_MANAGERS = ['rpm', 'dpkg']
def _rpm_info(rpm_package):
"""\
Private function that returns a dictionary with information about an
RPM package file
- type: Package management program that handles the file
- system_support: If the package management program is installed on the
system or not
- source: If it is a source (True) our binary (False) package
- version: The package version (or name), that is used to check against the
package manager if the package is installed
- arch: The architecture for which a binary package was built
- installed: Whether the package is installed (True) on the system or not
(False)
"""
# We will make good use of what the file command has to tell us about the
# package :)
file_result = utils.system_output('file ' + rpm_package)
package_info = {}
package_info['type'] = 'rpm'
try:
os_dep.command('rpm')
# Build the command strings that will be used to get package info
# s_cmd - Command to determine if package is a source package
# a_cmd - Command to determine package architecture
# v_cmd - Command to determine package version
# i_cmd - Command to determiine if package is installed
s_cmd = 'rpm -qp --qf %{SOURCE} ' + rpm_package + ' 2>/dev/null'
a_cmd = 'rpm -qp --qf %{ARCH} ' + rpm_package + ' 2>/dev/null'
v_cmd = 'rpm -qp ' + rpm_package + ' 2>/dev/null'
i_cmd = 'rpm -q ' + utils.system_output(v_cmd) + ' 2>&1 >/dev/null'
package_info['system_support'] = True
# Checking whether this is a source or src package
source = utils.system_output(s_cmd)
if source == '(none)':
package_info['source'] = False
else:
package_info['source'] = True
package_info['version'] = utils.system_output(v_cmd)
package_info['arch'] = utils.system_output(a_cmd)
# Checking if package is installed
try:
utils.system(i_cmd)
package_info['installed'] = True
except:
package_info['installed'] = False
except:
package_info['system_support'] = False
package_info['installed'] = False
# File gives a wealth of information about rpm packages.
# However, we can't trust all this info, as incorrectly
# packaged rpms can report some wrong values.
# It's better than nothing though :)
if len(file_result.split(' ')) == 6:
# Figure if package is a source package
if file_result.split(' ')[3] == 'src':
package_info['source'] = True
elif file_result.split(' ')[3] == 'bin':
package_info['source'] = False
else:
package_info['source'] = False
# Get architecture
package_info['arch'] = file_result.split(' ')[4]
# Get version
package_info['version'] = file_result.split(' ')[5]
elif len(file_result.split(' ')) == 5:
# Figure if package is a source package
if file_result.split(' ')[3] == 'src':
package_info['source'] = True
elif file_result.split(' ')[3] == 'bin':
package_info['source'] = False
else:
package_info['source'] = False
# When the arch param is missing on file, we assume noarch
package_info['arch'] = 'noarch'
# Get version
package_info['version'] = file_result.split(' ')[4]
else:
# If everything else fails...
package_info['source'] = False
package_info['arch'] = 'Not Available'
package_info['version'] = 'Not Available'
return package_info
def _dpkg_info(dpkg_package):
"""\
Private function that returns a dictionary with information about a
dpkg package file
- type: Package management program that handles the file
- system_support: If the package management program is installed on the
system or not
- source: If it is a source (True) our binary (False) package
- version: The package version (or name), that is used to check against the
package manager if the package is installed
- arch: The architecture for which a binary package was built
- installed: Whether the package is installed (True) on the system or not
(False)
"""
# We will make good use of what the file command has to tell us about the
# package :)
file_result = utils.system_output('file ' + dpkg_package)
package_info = {}
package_info['type'] = 'dpkg'
# There's no single debian source package as is the case
# with RPM
package_info['source'] = False
try:
os_dep.command('dpkg')
# Build the command strings that will be used to get package info
# a_cmd - Command to determine package architecture
# v_cmd - Command to determine package version
# i_cmd - Command to determiine if package is installed
a_cmd = 'dpkg -f ' + dpkg_package + ' Architecture 2>/dev/null'
v_cmd = 'dpkg -f ' + dpkg_package + ' Package 2>/dev/null'
i_cmd = 'dpkg -s ' + utils.system_output(v_cmd) + ' 2>/dev/null'
package_info['system_support'] = True
package_info['version'] = utils.system_output(v_cmd)
package_info['arch'] = utils.system_output(a_cmd)
# Checking if package is installed
package_status = utils.system_output(i_cmd, ignore_status=True)
not_inst_pattern = re.compile('not-installed', re.IGNORECASE)
dpkg_not_installed = re.search(not_inst_pattern, package_status)
if dpkg_not_installed:
package_info['installed'] = False
else:
package_info['installed'] = True
except:
package_info['system_support'] = False
package_info['installed'] = False
# The output of file is not as generous for dpkg files as
# it is with rpm files
package_info['arch'] = 'Not Available'
package_info['version'] = 'Not Available'
return package_info
def list_all():
"""Returns a list with the names of all currently installed packages."""
support_info = os_support()
installed_packages = []
if support_info['rpm']:
installed_packages += utils.system_output('rpm -qa').splitlines()
if support_info['dpkg']:
raw_list = utils.system_output('dpkg -l').splitlines()[5:]
for line in raw_list:
parts = line.split()
if parts[0] == "ii": # only grab "installed" packages
installed_packages.append("%s-%s" % (parts[1], parts[2]))
return installed_packages
def info(package):
"""\
Returns a dictionary with package information about a given package file:
- type: Package management program that handles the file
- system_support: If the package management program is installed on the
system or not
- source: If it is a source (True) our binary (False) package
- version: The package version (or name), that is used to check against the
package manager if the package is installed
- arch: The architecture for which a binary package was built
- installed: Whether the package is installed (True) on the system or not
(False)
Implemented package types:
- 'dpkg' - dpkg (debian, ubuntu) package files
- 'rpm' - rpm (red hat, suse) package files
Raises an exception if the package type is not one of the implemented
package types.
"""
if not os.path.isfile(package):
raise ValueError('invalid file %s to verify' % package)
# Use file and libmagic to determine the actual package file type.
file_result = utils.system_output('file ' + package)
for package_manager in KNOWN_PACKAGE_MANAGERS:
if package_manager == 'rpm':
package_pattern = re.compile('RPM', re.IGNORECASE)
elif package_manager == 'dpkg':
package_pattern = re.compile('Debian', re.IGNORECASE)
result = re.search(package_pattern, file_result)
if result and package_manager == 'rpm':
return _rpm_info(package)
elif result and package_manager == 'dpkg':
return _dpkg_info(package)
# If it's not one of the implemented package manager methods, there's
# not much that can be done, hence we throw an exception.
raise error.PackageError('Unknown package type %s' % file_result)
def install(package, nodeps = False):
"""\
Tries to install a package file. If the package is already installed,
it prints a message to the user and ends gracefully. If nodeps is set to
true, it will ignore package dependencies.
"""
my_package_info = info(package)
type = my_package_info['type']
system_support = my_package_info['system_support']
source = my_package_info['source']
installed = my_package_info['installed']
if not system_support:
e_msg = ('Client does not have package manager %s to handle %s install'
% (type, package))
raise error.PackageError(e_msg)
opt_args = ''
if type == 'rpm':
if nodeps:
opt_args = opt_args + '--nodeps'
install_command = 'rpm %s -U %s' % (opt_args, package)
if type == 'dpkg':
if nodeps:
opt_args = opt_args + '--force-depends'
install_command = 'dpkg %s -i %s' % (opt_args, package)
# RPM source packages can be installed along with the binary versions
# with this check
if installed and not source:
return 'Package %s is already installed' % package
# At this point, the most likely thing to go wrong is that there are
# unmet dependencies for the package. We won't cover this case, at
# least for now.
utils.system(install_command)
return 'Package %s was installed successfuly' % package
def convert(package, destination_format):
"""\
Convert packages with the 'alien' utility. If alien is not installed, it
throws a NotImplementedError exception.
returns: filename of the package generated.
"""
try:
os_dep.command('alien')
except:
e_msg = 'Cannot convert to %s, alien not installed' % destination_format
raise error.TestError(e_msg)
# alien supports converting to many formats, but its interesting to map
# convertions only for the implemented package types.
if destination_format == 'dpkg':
deb_pattern = re.compile('[A-Za-z0-9_.-]*[.][d][e][b]')
conv_output = utils.system_output('alien --to-deb %s 2>/dev/null'
% package)
converted_package = re.findall(deb_pattern, conv_output)[0]
elif destination_format == 'rpm':
rpm_pattern = re.compile('[A-Za-z0-9_.-]*[.][r][p][m]')
conv_output = utils.system_output('alien --to-rpm %s 2>/dev/null'
% package)
converted_package = re.findall(rpm_pattern, conv_output)[0]
else:
e_msg = 'Convertion to format %s not implemented' % destination_format
raise NotImplementedError(e_msg)
print 'Package %s successfuly converted to %s' % \
(os.path.basename(package), os.path.basename(converted_package))
return os.path.abspath(converted_package)
def os_support():
"""\
Returns a dictionary with host os package support info:
- rpm: True if system supports rpm packages, False otherwise
- dpkg: True if system supports dpkg packages, False otherwise
- conversion: True if the system can convert packages (alien installed),
or False otherwise
"""
support_info = {}
for package_manager in KNOWN_PACKAGE_MANAGERS:
try:
os_dep.command(package_manager)
support_info[package_manager] = True
except:
support_info[package_manager] = False
try:
os_dep.command('alien')
support_info['conversion'] = True
except:
support_info['conversion'] = False
return support_info