def get_available_version(self, pkgname):
"""
Check which version is available.
"""
if self.cache:
self.log.obnoxious("Checking apt for `{0}'".format(pkgname))
(ver, is_installed) = self.check_cache(pkgname)
if ver:
self.log.debug("Package {0} has version {1} in repositories".format(pkgname, ver))
return ver
else:
try:
self.log.obnoxious("Checking {0} for `{1}'".format(self.searchcmd, pkgname))
ver = subproc.match_output(
[self.searchcmd, "show", pkgname],
r'Version: (?:\d+:)?(?P<ver>[0-9]+\.[0-9]+\.[0-9]+|[0-9]+\.[0-9]+|[0-9]+[a-z]+|[0-9]+).*\n',
'ver'
)
if ver is None:
return False
if ver:
self.log.debug("Package {0} has version {1} in repositories".format(pkgname, ver))
return ver
except subprocess.CalledProcessError:
# Could be an issue, but most likely it means the package doesn't exist.
self.log.debug(
"{cmd} show {pkg} failed.".format(cmd=self.searchcmd, pkg=pkgname)
)
return False
def get_available_version(self, pkgname):
"""
Check which version is available.
"""
if self.cache:
self.log.obnoxious("Checking apt for `{0}'".format(pkgname))
(ver, is_installed) = self.check_cache(pkgname)
if ver:
self.log.debug("Package {0} has version {1} in repositories".format(pkgname, ver))
return ver
else:
try:
self.log.obnoxious("Checking {0} for `{1}'".format(self.searchcmd, pkgname))
ver = subproc.match_output(
[self.searchcmd, "show", pkgname],
r'Version: (?:\d+:)?(?P<ver>[0-9]+\.[0-9]+\.[0-9]+|[0-9]+\.[0-9]+|[0-9]+[a-z]+|[0-9]+).*\n',
'ver'
)
if ver is None:
return False
if ver:
self.log.debug("Package {0} has version {1} in repositories".format(pkgname, ver))
return ver
except subprocess.CalledProcessError:
self.log.error("Error running {0} show. This shouldn't happen. Probably a bug.".format(pkgname))
return False
def get_installed_version(self, command):
"""
Run command, see if it works. If the output has a version number in
x.y.z format, return that. If it doesn't, but the command ran, return
True. If it fails, return False. ezpz.
"""
try:
# If this fails, it almost always throws.
# NOTE: the split is to handle multi-argument commands. There's
# cases where this is not intended, e.g. it won't handle arguments
# with spaces! But currently this is preferable to running the
# command in a shell.
ver = subproc.match_output(
command.split(),
r'(?P<ver>[0-9]+\.[0-9]+(\.[0-9]+)?)',
'ver'
)
if ver is None:
self.log.debug("Could run, but couldn't find a version number.")
return True
self.log.debug("Found version number: {0}".format(ver))
return ver
except (subprocess.CalledProcessError, OSError):
# We'll assume it's not installed
return False
except Exception as e:
self.log.error("Running `{0}` failed.".format(command))
self.log.obnoxious(str(e))
return False
def get_installed_version(self, pkgname):
"""
Use dpkg (or python-apt) to determine and return the currently installed version.
If pkgname is not installed, return None.
"""
if self.cache:
(ver, is_installed) = self.check_cache(pkgname)
if is_installed:
self.log.debug("Package {0} has version {1} installed".format(pkgname, ver))
return ver if is_installed else False
else:
try:
ver = subproc.match_output(
["dpkg", "-s", pkgname],
r'^Version: (?:\d+:)?(?P<ver>[0-9]+\.[0-9]+\.[0-9]+|[0-9]+\.[0-9]+|[0-9]+[a-z]+|[0-9]+)',
'ver'
)
if ver is None:
self.log.debug("Looks like dpkg -s can't find package {pkg}. This is most likely a bug.".format(pkg=pkgname))
return False
self.log.debug("Package {0} has version {1} installed".format(pkgname, ver))
return ver
except subprocess.CalledProcessError:
# This usually means the packet is not installed -- not a problem.
return False
except Exception as e:
self.log.error("Running dpkg -s failed.")
self.log.obnoxious(str(e))
return False
def get_installed_version(self, pkgname):
"""
Return the currently installed version. If pkgname is not installed,
return None.
"""
try:
# '-Qi' will return non-zero if package does not exist, thus will throw
# Output is sth like local/<pkgname> x.x.x.x-x
ver = subproc.match_output(
[self.command, "-Qi", pkgname],
r'Version[ ]*: (?P<ver>[0-9,.]*)',
'ver'
)
if ver is None:
self.log.debug("Looks like pacman -Qi can't find package {pkg}".format(pkg=pkgname))
return False
self.log.debug("Package {0} has version {1}".format(pkgname, ver))
return ver
except subprocess.CalledProcessError:
# This usually means the packet is not installed
return False
except Exception as ex:
self.log.error("Parsing `{0} -Qi` failed.".format(self.command))
self.log.trace(str(ex))
return False
def get_installed_version(self, pkgname):
"""
Use dpkg (or python-apt) to determine and return the currently installed version.
If pkgname is not installed, return None.
"""
if self.cache:
(ver, is_installed) = self.check_cache(pkgname)
if is_installed:
self.log.debug("Package {0} has version {1} installed".format(
pkgname, ver))
return ver if is_installed else False
else:
try:
ver = subproc.match_output([
"dpkg", "-s", pkgname
], r'^Version: (?:\d+:)?(?P<ver>[0-9]+\.[0-9]+\.[0-9]+|[0-9]+\.[0-9]+|[0-9]+[a-z]+|[0-9]+)',
'ver')
if ver is None:
self.log.debug(
"Looks like dpkg -s can't find package {pkg}. This is most likely a bug."
.format(pkg=pkgname))
return False
self.log.debug("Package {0} has version {1} installed".format(
pkgname, ver))
return ver
except subprocess.CalledProcessError:
# This usually means the packet is not installed -- not a problem.
return False
except Exception as e:
self.log.error("Running dpkg -s failed.")
self.log.obnoxious(str(e))
return False
def get_available_version(self, pkgname):
"""
Return a version that we can install through this package manager.
"""
try:
ver = subproc.match_output(
[self.command, "info", pkgname],
r'^Version\s+:\s+(?P<ver>.*$)',
'ver',
env=utils.dict_merge(os.environ, {'LC_ALL': 'C'}),
)
if ver is None:
return False
self.log.debug("Package {0} has version {1} in {2}".format(
pkgname, ver, self.command))
return ver
except subprocess.CalledProcessError as ex:
# This usually means the package was not found, so don't worry
self.log.obnoxious(
"`{0} info' returned non-zero exit status.".format(
self.command))
self.log.obnoxious(str(ex))
return False
except Exception as ex:
self.log.error("Error parsing {0} info".format(self.command))
self.log.error(str(ex))
return False
def get_available_version(self, pkgname):
"""
Check which version is available.
"""
if self.cache:
self.log.obnoxious("Checking apt for `{0}'".format(pkgname))
(ver, is_installed) = self.check_cache(pkgname)
if ver:
self.log.debug("Package {0} has version {1} in repositories".format(pkgname, ver))
return ver
else:
try:
self.log.obnoxious("Checking {0} for `{1}'".format(self.searchcmd, pkgname))
ver = subproc.match_output(
[self.searchcmd, "show", pkgname],
r'Version: (?:\d+:)?(?P<ver>[0-9]+\.[0-9]+\.[0-9]+|[0-9]+\.[0-9]+|[0-9]+[a-z]+|[0-9]+).*\n',
'ver'
)
if ver is None:
return False
if ver:
self.log.debug("Package {0} has version {1} in repositories".format(pkgname, ver))
return ver
except subprocess.CalledProcessError:
# Could be an issue, but most likely it means the package doesn't exist.
self.log.debug(
"{cmd} show {pkg} failed.".format(cmd=self.searchcmd, pkg=pkgname)
)
return False
def get_available_version(self, pkgname):
"""
Check which version is available.
"""
if self.cache:
self.log.obnoxious("Checking apt for `{0}'".format(pkgname))
(ver, is_installed) = self.check_cache(pkgname)
if ver:
self.log.debug(
"Package {0} has version {1} in repositories".format(
pkgname, ver))
return ver
else:
try:
self.log.obnoxious("Checking {0} for `{1}'".format(
self.searchcmd, pkgname))
ver = subproc.match_output([
self.searchcmd, "show", pkgname
], r'Version: (?:\d+:)?(?P<ver>[0-9]+\.[0-9]+\.[0-9]+|[0-9]+\.[0-9]+|[0-9]+[a-z]+|[0-9]+).*\n',
'ver')
if ver is None:
return False
if ver:
self.log.debug(
"Package {0} has version {1} in repositories".format(
pkgname, ver))
return ver
except subprocess.CalledProcessError:
self.log.error(
"Error running {0} show. This shouldn't happen. Probably a bug."
.format(pkgname))
return False
def get_installed_version(self, pkgname):
"""
Return the currently installed version. If pkgname is not installed,
return None.
"""
try:
# '-Qi' will return non-zero if package does not exist, thus will throw
# Output is sth like local/<pkgname> x.x.x.x-x
ver = subproc.match_output([self.command, "-Si", pkgname],
r'Version[ ]*: (?P<ver>[0-9,.]*)',
'ver')
if ver is None:
self.log.debug(
"Looks like pacman -Qi can't find package {pkg}".format(
pkg=pkgname))
return False
self.log.debug("Package {} has version {}".format(pkgname, ver))
return ver
except subprocess.CalledProcessError:
# This usually means the packet is not installed
return False
except Exception as ex:
self.log.error("Parsing `{0} -Qi` failed.".format(self.command))
self.log.obnoxious(str(ex))
return False
def get_available_version(self, pkgname):
"""
See if 'pip search' finds our package.
"""
try:
output_match = subproc.match_output(
["pip", "search", pkgname],
r'^\b{pkg}\b'.format(pkg=pkgname),
)
return bool(output_match)
except subproc.CalledProcessError:
return False
except Exception as ex:
self.log.error("Error running `pip search {0}`".format(pkgname))
self.log.debug(ex)
return False
def get_available_version(self, pkgname):
"""
See if 'pip search' finds our package.
"""
try:
output_match = subproc.match_output(
["pip", "search", pkgname],
r'^\b{pkg}\b'.format(pkg=pkgname),
)
return bool(output_match)
except subproc.CalledProcessError:
return False
except Exception as ex:
self.log.error("Error running `pip search {0}`".format(pkgname))
self.log.debug(ex)
return False
def get_available_version(self, pkgname):
"""
Check which version is available in apt-cache.
"""
try:
self.log.obnoxious("Checking apt-cache for `{0}'".format(pkgname))
ver = subproc.match_output(
["apt-cache", "showpkg", pkgname],
r'Versions: \n(?:\d+:)?(?P<ver>[0-9]+\.[0-9]+\.[0-9]+|[0-9]+\.[0-9]+|[0-9]+[a-z]+|[0-9]+).*\n',
'ver'
)
if ver is None:
return False
if ver:
self.log.debug("Package {} has version {} in apt-cache".format(pkgname, ver))
return ver
except subprocess.CalledProcessError:
self.log.error("Error running apt-cache showpkg. This shouldn't happen. Probably a bug.")
return False
def get_available_version(self, pkgname):
"""
Check which version is available in apt-cache.
"""
try:
self.log.obnoxious("Checking apt-cache for `{0}'".format(pkgname))
ver = subproc.match_output([
"apt-cache", "showpkg", pkgname
], r'Versions: \n(?:\d+:)?(?P<ver>[0-9]+\.[0-9]+\.[0-9]+|[0-9]+\.[0-9]+|[0-9]+[a-z]+|[0-9]+).*\n',
'ver')
if ver is None:
return False
if ver:
self.log.debug("Package {} has version {} in apt-cache".format(
pkgname, ver))
return ver
except subprocess.CalledProcessError:
self.log.error(
"Error running apt-cache showpkg. This shouldn't happen. Probably a bug."
)
return False
def get_available_version(self, pkgname):
"""
Return a version that we can install through this package manager.
"""
try:
ver = subproc.match_output(
[self.command, "-Si", pkgname],
r'Version[ ]*: (?P<ver>[0-9,.]*)',
'ver'
) or False
if ver:
self.log.debug("Package {0} has version {1} in {2}".format(pkgname, ver, self.command))
return ver
except subprocess.CalledProcessError as ex:
# This usually means the package was not found, so don't worry
self.log.trace("`{0} -Si' returned non-zero exit status.".format(self.command))
self.log.trace(str(ex))
return False
except Exception as ex:
self.log.error("Error parsing {0} -Si".format(self.command))
self.log.error(str(ex))
return False
def get_available_version(self, pkgname):
"""
Return a version that we can install through this package manager.
"""
try:
ver = subproc.match_output([self.command, "-Si", pkgname],
r'Version[ ]*: (?P<ver>[0-9,.]*)',
'ver') or False
if ver:
self.log.debug("Package {0} has version {1} in {2}".format(
pkgname, ver, self.command))
return ver
except subprocess.CalledProcessError as ex:
# This usually means the package was not found, so don't worry
self.log.trace("`{0} -Si' returned non-zero exit status.".format(
self.command))
self.log.trace(str(ex))
return False
except Exception as ex:
self.log.error("Error parsing {0} -Si".format(self.command))
self.log.error(str(ex))
return False
def get_available_version(self, pkgname):
"""
Return a version that we can install through this package manager.
"""
try:
ver = subproc.match_output(
[self.command, "info", pkgname],
r'^Version\s+:\s+(?P<ver>.*$)',
'ver'
)
if ver is None:
return False
self.log.debug("Package {} has version {} in {}".format(pkgname, ver, self.command))
return ver
except subprocess.CalledProcessError as ex:
# This usually means the package was not found, so don't worry
self.log.obnoxious("`{0} info' returned non-zero exit status.".format(self.command))
self.log.obnoxious(str(ex))
return False
except Exception as ex:
self.log.error("Error parsing {0} info".format(self.command))
self.log.error(str(ex))
return False
