def reload(args):
"""Reload system daemons (see LIST-DAEMONS for available daemons)"""
command = "/usr/sbin/service {} reload".format(args.daemon)
if perform.execute(command, root=True):
print("attempt FORCE-RELOAD instead")
command = "/usr/sbin/service {} force-reload ".format(args.daemon)
perform.execute(command, root=True)
def download(args):
"""Download one or more packages without installing them"""
print("Packages being downloaded to /var/cache/apt/archives/")
command = "/usr/bin/apt-get --reinstall --download-only install "
packages = util.consolidate_package_names(args)
command = command + " ".join(packages)
perform.execute(command, root=True)
def search(args):
"""Search for package names containing the given pattern
If '::' is found in the search term, use a debtags search; example:
$ wajig search implemented-in::python
balazar - adventure/action game Balazar -- Arkanae II, reforged scepters
compizconfig-settings-manager - Compizconfig Settings Manager
...
"""
if len(args.patterns) == 1 and '::' in args.patterns[0]:
util.requires_package('debtags')
command = 'debtags search ' + args.patterns[0]
if args.verbose:
command += ' --full'
elif not args.verbose:
command = "apt-cache --names-only search {}"
command = command.format(" ".join(args.patterns))
elif args.verbose == 1:
import shlex
args.patterns = [shlex.quote(pattern) for pattern in args.patterns]
command = "apt-cache search {} | grep -E --ignore-case '{}'"
command = command.format(" ".join(args.patterns),
"\|".join(args.patterns))
else:
command = "apt-cache search --full " + " ".join(args.patterns)
perform.execute(command)
def purge(args):
"""Remove one or more packages and their configuration files"""
packages = util.consolidate_package_names(args)
command = "/usr/bin/apt-get {} {} --auto-remove purge "
command = command.format(args.yes, args.noauth)
command = command + " ".join(packages)
perform.execute(command, root=True, log=True)
def purge(args):
"""Remove one or more packages and their configuration files"""
packages = util.consolidate_package_names(args)
command = "/usr/bin/apt-get {} {} --auto-remove purge "
command = command.format(args.yes, args.noauth)
command = command + " ".join(packages)
perform.execute(command, root=True, log=True)
def localupgrade(args):
"""Upgrade using only packages that are already downloaded"""
command = (
"/usr/bin/apt-get --no-download --ignore-missing "
"--show-upgraded upgrade"
)
perform.execute(command, root=True, log=True)
def recommended(args):
"""Display packages installed as Recommends and have no dependents"""
perform.execute(
"aptitude search "
"'?and( ?automatic(?reverse-recommends(?installed)), "
"?not(?automatic(?reverse-depends(?installed))) )'"
)
def reload(args):
"""Reload system daemons (see LIST-DAEMONS for available daemons)"""
command = "/usr/sbin/service {} reload".format(args.daemon)
if perform.execute(command, root=True):
print("attempt FORCE-RELOAD instead")
command = "/usr/sbin/service {} force-reload ".format(args.daemon)
perform.execute(command, root=True)
def search(args):
"""Search for package names containing the given pattern
If '::' is found in the search term, use a debtags search; example:
$ wajig search implemented-in::python
balazar - adventure/action game Balazar -- Arkanae II, reforged scepters
compizconfig-settings-manager - Compizconfig Settings Manager
...
"""
if len(args.patterns) == 1 and '::' in args.patterns[0]:
util.requires_package('debtags')
command = 'debtags search ' + args.patterns[0]
if args.verbose:
command += ' --full'
elif not args.verbose:
command = "apt --names-only search {}"
command = command.format(" ".join(args.patterns))
elif args.verbose == 1:
import shlex
args.patterns = [shlex.quote(pattern) for pattern in args.patterns]
command = "apt search {} | grep -E --ignore-case '{}'"
command = command.format(" ".join(args.patterns),
"\|".join(args.patterns))
else:
command = "apt search --full " + " ".join(args.patterns)
perform.execute(command)
def download(args):
"""Download one or more packages without installing them"""
print("Packages being downloaded to /var/cache/apt/archives/")
command = "/usr/bin/apt-get --reinstall --download-only install "
packages = util.consolidate_package_names(args)
command = command + " ".join(packages)
perform.execute(command, root=True)
def editsources(args):
"""Edit list of Debian repository locations for packages"""
editor = (
os.environ.get('VISUAL') or
os.environ.get('EDITOR') or
'/usr/bin/sensible-editor'
)
perform.execute(editor + ' /etc/apt/sources.list', root=True)
def liststatus(args):
"""Same as list but only prints first two columns, not truncated"""
command = "COLUMNS=400 "
command += "dpkg --list '*' | grep -E -v 'no description avail'"
command += " | awk '{print $1,$2}'"
if args.pattern:
command += " | grep -E '{}' | sort -k 1b,1".format(args.pattern)
perform.execute(command)
def versions(args):
"""List version and distribution of given packages"""
util.requires_package("apt-show-versions")
if args.packages:
for package in args.packages:
perform.execute("apt-show-versions " + package)
else:
perform.execute("apt-show-versions")
def versions(args):
"""List version and distribution of given packages"""
util.requires_package("apt-show-versions")
if args.packages:
for package in args.packages:
perform.execute("apt-show-versions " + package)
else:
perform.execute("apt-show-versions")
def liststatus(args):
"""Same as list but only prints first two columns, not truncated"""
command = "COLUMNS=400 "
command += "dpkg --list '*' | grep -E -v 'no description avail'"
command += " | awk '{print $1,$2}'"
if args.pattern:
command += " | grep -E '{}' | sort -k 1b,1".format(args.pattern)
perform.execute(command)
def do_describe(packages, verbose=False, die=True):
"""Display package description(s)"""
package_files = [
package for package in packages if package.endswith(".deb")
]
package_names = [
package for package in packages if not package.endswith(".deb")
]
if package_files:
for package_file in package_files:
perform.execute("dpkg-deb --info " + package_file)
print("=" * 72)
sys.stdout.flush()
if package_names:
packages = package_names
else:
return
if not packages:
print("No packages found from those known to be available/installed.")
else:
packageversions = list()
cache = apt.cache.Cache()
for package in packages:
try:
package = cache[package]
except KeyError as e:
import subprocess
command = 'dpkg --print-foreign-architectures'.split()
output = subprocess.check_output(command)
for arch in output.decode().split():
try:
package = cache["{}:{}".format(package, arch)]
# to avoid noise, only consider the 1st match
break
except KeyError:
pass
if not isinstance(package, apt.package.Package) and die:
print(str(e).strip('"'))
return 1
packageversion = package.installed
if not packageversion: # if package is not installed...
packageversion = package.candidate
packageversions.append((package.shortname, packageversion.summary,
packageversion.description))
packageversions = set(packageversions)
if verbose:
for packageversion in packageversions:
print("{}: {}\n{}\n".format(packageversion[0],
packageversion[1],
packageversion[2]))
else:
print("{0:24} {1}".format("Package", "Description"))
print("=" * 24 + "-" + "=" * 51)
for packageversion in packageversions:
print("%-24s %s" % (packageversion[0], packageversion[1]))
def hold(args):
"""Place packages on hold (so they will not be upgraded)"""
for package in args.packages:
# The dpkg needs sudo but not the echo.
# Do all of it as root then!
command = '/bin/echo "{} hold" | /usr/bin/dpkg --set-selections'
perform.execute(command.format(package), root=True)
print("The following packages are on hold:")
perform.execute("dpkg --get-selections | grep -E 'hold$' | cut -f1")
def newly_available(verbose=False):
"""display brand-new packages.. technically new package names"""
with open(new_file) as f:
packages = f.readlines()
if verbose:
for package in packages:
perform.execute('aptitude show ' + package)
else:
do_describe([package.strip() for package in packages], die=False)
def unhold(args):
"""Remove listed packages from hold so they are again upgradeable"""
for package in args.packages:
# The dpkg needs sudo but not the echo.
# Do all of it as root then.
command = "echo \"" + package + " install\" | dpkg --set-selections"
perform.execute(command, root=True)
print("The following packages are still on hold:")
perform.execute("dpkg --get-selections | grep -E 'hold$' | cut -f1")
def unhold(args):
"""Remove listed packages from hold so they are again upgradeable"""
for package in args.packages:
# The dpkg needs sudo but not the echo.
# Do all of it as root then.
command = "echo \"" + package + " install\" | dpkg --set-selections"
perform.execute(command, root=1)
print("The following packages are still on hold:")
perform.execute("dpkg --get-selections | grep -E 'hold$' | cut -f1")
def hold(args):
"""Place packages on hold (so they will not be upgraded)"""
for package in args.packages:
# The dpkg needs sudo but not the echo.
# Do all of it as root then!
command = "/bin/echo \"" + package + " hold\" | /usr/bin/dpkg --set-selections"
perform.execute(command, root=True)
print("The following packages are on hold:")
perform.execute("dpkg --get-selections | grep -E 'hold$' | cut -f1")
def addrepo(args):
"""Add a Launchpad PPA (Personal Package Archive) repository
An example that shows how to add the daily builds of
Google's Chromium browser:
$ wajig addrepo ppa:chromium-daily"""
util.requires_package("add-apt-repository")
perform.execute("/usr/bin/add-apt-repository " + args.ppa, root=True)
def changelog(args):
"""Display Debian changelog of a package
network on:
changelog - if there's newer entries, display them
-v changelog - if there's newer entries, display them, and proceed to
display complete local changelog
network off:
changelog - if there's newer entries, mention failure to retrieve
-v changelog - if there's newer entries, mention failure to retrieve, and
proceed to display complete local changelog
"""
package = util.package_exists(apt.Cache(), args.package)
changelog = "{:=^79}\n".format(" {} ".format(args.package)) # header
try:
changelog += package.get_changelog()
except AttributeError:
# This is caught so as to avoid an ugly python-apt trace; it's a bug
# that surfaces when:
# 1. The package is not available in the default Debian suite
# 2. The suite the package belongs to is set to a pin of < 0
print("If this package is not on your default Debian suite, " \
"ensure that its APT pinning isn't less than 0.")
return
help_message = "\nTo display the local changelog, run:\n" \
"wajig changelog --verbose " + args.package
if "Failed to download the list of changes" in changelog:
if not args.verbose:
changelog += help_message
else:
changelog += "\n"
elif changelog.endswith("The list of changes is not available"):
changelog += ".\nYou are likely running the latest version.\n"
if not args.verbose:
changelog += help_message
if not args.verbose:
print(changelog)
else:
tmp = tempfile.mkstemp()[1]
with open(tmp, "w") as f:
if package.is_installed:
changelog += "{:=^79}\n".format(" local changelog ")
f.write(changelog)
if package.is_installed:
command = util.local_changelog(args.package, tmp)
if not command:
return
perform.execute(command)
with open(tmp) as f:
for line in f:
try:
print(line, end="")
except BrokenPipeError:
return
def newly_available(verbose=False):
"""display brand-new packages.. technically new package names"""
with open(new_file) as f:
packages = f.readlines()
if verbose:
for package in packages:
perform.execute('aptitude show ' + package)
else:
do_describe([package.strip() for package in packages], die=False)
def build(args):
"""Get source packages, unpack them, and build binary packages from them.
This also installs the needed build-dependencies if needed."""
util.requires_package("sudo")
# First make sure dependencies are met
if not builddeps(args):
command = "apt-get {} source --build " + " ".join(args.packages)
command = command.format(args.noauth)
perform.execute(command)
def do_describe(packages, verbose=False, die=True):
"""Display package description(s)"""
package_files = [package for package in packages
if package.endswith(".deb")]
package_names = [package for package in packages
if not package.endswith(".deb")]
if package_files:
for package_file in package_files:
perform.execute("dpkg-deb --info " + package_file)
print("="*72)
sys.stdout.flush()
if package_names:
packages = package_names
else:
return
if not packages:
print("No packages found from those known to be available/installed.")
else:
packageversions = list()
cache = apt.cache.Cache()
for package in packages:
try:
package = cache[package]
except KeyError as e:
import subprocess
command = 'dpkg --print-foreign-architectures'.split()
output = subprocess.check_output(command)
for arch in output.decode().split():
try:
package = cache["{}:{}".format(package, arch)]
# to avoid noise, only consider the 1st match
break
except KeyError:
pass
if not isinstance(package, apt.package.Package) and die:
print(str(e).strip('"'))
return 1
packageversion = package.installed
if not packageversion: # if package is not installed...
packageversion = package.candidate
packageversions.append((package.shortname, packageversion.summary,
packageversion.description))
packageversions = set(packageversions)
if verbose:
for packageversion in packageversions:
print("{}: {}\n{}\n".format(packageversion[0],
packageversion[1],
packageversion[2]))
else:
print("{0:24} {1}".format("Package", "Description"))
print("="*24 + "-" + "="*51)
for packageversion in packageversions:
print("%-24s %s" % (packageversion[0], packageversion[1]))
def listall(args):
"""List one line descriptions for all packages"""
command = ("apt-cache dumpavail |"
"grep -E \"^(Package|Description): \" |"
"awk '/^Package: /{pkg=$2} /^Description: /"
"{printf(\"%-24s %s\\n\", pkg,"
"substr($0,13))}' | sort -u -k 1b,1")
if args.pattern:
command = "{} | grep -E '{}'".format(command, args.pattern)
perform.execute(command)
def addrepo(args):
"""Add a Launchpad PPA (Personal Package Archive) repository
An example that shows how to add the daily builds of
Google's Chromium browser:
$ wajig addrepo ppa:chromium-daily
"""
util.requires_package("add-apt-repository")
perform.execute("/usr/bin/add-apt-repository " + args.ppa, root=True)
def removeorphans(args):
"""Remove orphaned libraries"""
util.requires_package("deborphan")
packages = ""
for package in perform.execute("deborphan", pipe=True):
packages += " " + package.strip()
if packages:
command = "/usr/bin/apt-get --auto-remove remove {} {}"
command = command.format(args.yes, packages)
perform.execute(command, root=True, log=True)
def listcache(args):
"""List the contents of the download cache"""
command = "printf 'Found %d files %s in the cache.\n\n'\
$(ls /var/cache/apt/archives/ | wc -l) \
$(ls -sh /var/cache/apt/archives/ | head -1 | awk '{print $2}')"
perform.execute(command)
command = "ls /var/cache/apt/archives/"
if args.pattern:
command = "{} | grep -E '{}'".format(command, args.pattern)
perform.execute(command)
def listdaemons(args):
"""List the daemons that wajig can start, stop, restart, or reload"""
command = ("printf 'Found %d daemons in /etc/init.d.\n\n' "
"$(ls /etc/init.d/ | "
"grep -E -v '(~$|README|-(old|dist)|\.[0-9]*$)' | wc -l)")
perform.execute(command)
command = ("ls /etc/init.d/ | "
"grep -E -v '(~$|README|-(old|dist)|\.[0-9]*$)' |"
"pr --columns=3 --omit-header")
perform.execute(command)
def removeorphans(args):
"""Remove orphaned libraries"""
util.requires_package("deborphan")
packages = ""
for package in perform.execute("deborphan", pipe=True):
packages += " " + package.strip()
if packages:
command = "/usr/bin/apt-get --auto-remove remove {} {}"
command = command.format(args.yes, packages)
perform.execute(command, root=True, log=True)
def listcache(args):
"""List the contents of the download cache"""
command = "printf 'Found %d files %s in the cache.\n\n'\
$(ls /var/cache/apt/archives/ | wc -l) \
$(ls -sh /var/cache/apt/archives/ | head -1 | awk '{print $2}')"
perform.execute(command)
command = "ls /var/cache/apt/archives/"
if args.pattern:
command = "{} | grep -E '{}'".format(command, args.pattern)
perform.execute(command)
def listall(args):
"""List one line descriptions for all packages"""
command = ("apt-cache dumpavail |"
"grep -E \"^(Package|Description): \" |"
"awk '/^Package: /{pkg=$2} /^Description: /"
"{printf(\"%-24s %s\\n\", pkg,"
"substr($0,13))}' | sort -u -k 1b,1")
if args.pattern:
command = "{} | grep -E '{}'".format(command, args.pattern)
perform.execute(command)
def update_available(noreport=False):
"""Generate current list of available packages, backing up the old list
"""
if not os.path.exists(available_file):
f = open(available_file, "w")
f.close()
temporary_file = tempfile.mkstemp()[1]
os.rename(available_file, temporary_file)
# sort --unique so packages with more that one architecture are included
# only once. This makes the count shown by "update" consistent with the
# output of "toupgrade", though not necessarily with the list shown
# by "upgrade" (really "apt-get --show-upgraded upgrade"), which might
# show amd64 and i386 versions.
command = ("apt-cache dumpavail "
"| egrep '^(Package|Version):' "
"| tr '\n' ' '"
"| perl -p -e 's|Package: |\n|g; s|Version: ||g'"
"| sort -u -k 1b,1 | tail -n +2 | sed 's| $||' > ") \
+ available_file
# Use langC in the following since it uses a grep.
perform.execute(command, langC=True) # root is not required.
os.rename(temporary_file, previous_file)
available_packages = open(available_file).readlines()
previous_packages = open(previous_file).readlines()
diff = len(available_packages) - len(previous_packages)
temporary_file = tempfile.mkstemp()[1]
# 090425 Use langC=True to work with change from coreutils 6.10 to 7.2
command = "join -v 1 -t' ' {0} {1} | cut -d' ' -f 1 | tee {2} | wc -l"
command = command.format(available_file, previous_file, temporary_file)
newest = perform.execute(command, pipe=True, langC=True)
newest = newest.readlines()[0].strip()
if newest != "0":
os.rename(temporary_file, new_file)
else:
os.remove(temporary_file)
if not noreport:
if diff < 0:
direction = str(0 - diff) + " down on"
elif diff == 0:
direction = "the same as"
else:
direction = str(diff) + " up on"
print("This is " + direction + " the previous count", end=' ')
print("with " + newest + " new", end=' ')
if newest == "1":
print("package.")
else:
print("packages.")
def update_available(noreport=False):
"""Generate current list of available packages, backing up the old list
"""
if not os.path.exists(available_file):
f = open(available_file, "w")
f.close()
temporary_file = tempfile.mkstemp()[1]
os.rename(available_file, temporary_file)
# sort --unique so packages with more that one architecture are included
# only once. This makes the count shown by "update" consistent with the
# output of "toupgrade", though not necessarily with the list shown
# by "upgrade" (really "apt-get --show-upgraded upgrade"), which might
# show amd64 and i386 versions.
command = ("apt-cache dumpavail "
"| egrep '^(Package|Version):' "
"| tr '\n' ' '"
"| perl -p -e 's|Package: |\n|g; s|Version: ||g'"
"| sort -u -k 1b,1 | tail -n +2 | sed 's| $||' > ") \
+ available_file
# Use langC in the following since it uses a grep.
perform.execute(command, langC=True) # root is not required.
os.rename(temporary_file, previous_file)
available_packages = open(available_file).readlines()
previous_packages = open(previous_file).readlines()
diff = len(available_packages) - len(previous_packages)
temporary_file = tempfile.mkstemp()[1]
# 090425 Use langC=True to work with change from coreutils 6.10 to 7.2
command = "join -v 1 -t' ' {0} {1} | cut -d' ' -f 1 | tee {2} | wc -l"
command = command.format(available_file, previous_file, temporary_file)
newest = perform.execute(command, pipe=True, langC=True)
newest = newest.readlines()[0].strip()
if newest != "0":
os.rename(temporary_file, new_file)
else:
os.remove(temporary_file)
if not noreport:
if diff < 0:
direction = str(0 - diff) + " down on"
elif diff == 0:
direction = "the same as"
else:
direction = str(diff) + " up on"
print("This is " + direction + " the previous count", end=' ')
print("with " + newest + " new", end=' ')
if newest == "1":
print("package.")
else:
print("packages.")
def purgeremoved(args):
"""Purge all packages marked as deinstall"""
packages = ""
cmd = ("dpkg-query --show --showformat='${Package}\t${Status}\n' | "
"grep -E \"deinstall ok config-files\" | cut -f 1 ")
packages = perform.execute(cmd, pipe=True)
if packages:
packages = " ".join(packages)
packages = " ".join(packages.split())
perform.execute("/usr/bin/apt-get purge " + packages,
root=True, log=True)
def build(args):
"""Get source packages, unpack them, and build binary packages from them.
Note: This also installs the needed build-dependencies if needed
"""
util.requires_package("sudo")
# First make sure dependencies are met
if not builddeps(args):
command = "apt-get {} source --build " + " ".join(args.packages)
command = command.format(args.noauth)
perform.execute(command)
def changelog(args):
"""Display Debian changelog of a package
network on:
changelog - if there's newer entries, display them
-v changelog - if there's newer entries, display them, and proceed to
display complete local changelog
network off:
changelog - if there's newer entries, mention failure to retrieve
-v changelog - if there's newer entries, mention failure to retrieve, and
proceed to display complete local changelog"""
package = util.package_exists(apt.Cache(), args.package)
changelog = "{:=^79}\n".format(" {} ".format(args.package)) # header
try:
changelog += package.get_changelog()
except AttributeError as e:
# This is caught so as to avoid an ugly python-apt trace; it's a bug
# that surfaces when:
# 1. The package is not available in the default Debian suite
# 2. The suite the package belongs to is set to a pin of < 0
print("If this package is not on your default Debian suite, " \
"ensure that its APT pinning isn't less than 0.")
return
help_message = "\nTo display the local changelog, run:\n" \
"wajig changelog --verbose " + args.package
if "Failed to download the list of changes" in changelog:
if not args.verbose:
changelog += help_message
else:
changelog += "\n"
elif changelog.endswith("The list of changes is not available"):
changelog += ".\nYou are likely running the latest version.\n"
if not args.verbose:
changelog += help_message
if not args.verbose:
print(changelog)
else:
tmp = tempfile.mkstemp()[1]
with open(tmp, "w") as f:
if package.is_installed:
changelog += "{:=^79}\n".format(" local changelog ")
f.write(changelog)
if package.is_installed:
command = util.local_changelog(args.package, tmp)
if not command:
return
perform.execute(command)
with open(tmp) as f:
for line in f:
print(line, end="")
def purgeorphans(args):
"""Purge orphaned libraries (not required by installed packages)"""
# Deborphans does not require root, but dpkg does,
# so build up the orphans list first, then pass that to dpkg.
util.requires_package("deborphan")
packages = ""
for package in perform.execute("deborphan", pipe=True):
packages += " " + package.strip()
if packages:
command = "/usr/bin/apt-get --auto-remove purge {} {}"
command = command.format(args.yes, packages)
perform.execute(command, root=True, log=True)
def install(args):
"""Package installer
notes:
* specifying a .deb file will also try to satisfy that deb's dependencies;
* one can specify multiple files with --fileinput option
* specifying a url will try fetch the file from the internet, and keep it
in "~/.wajig/$HOSTNAME"
example:
$ wajig install a b_1.0_all.deb http://example.com/c_1.0_all.deb
Assuming there's no errors, the command will install 3 packages named
'a', 'b', and 'c''
"""
packages = util.consolidate_package_names(args)
online_files = [
package for package in packages if
package.startswith(("http://", "ftp://"))
]
deb_files = list()
for package in online_files:
if not package.endswith(".deb"):
print("A valid .deb file should have a '.deb' extension")
continue
filename = os.path.join(util.init_dir, package.split("/")[-1])
try:
response = urllib.request.urlopen(package)
except urllib.error.HTTPError as error:
print("{}; is '{}' the correct url?".format(error.reason, package))
else:
with open(filename, "wb") as f:
f.write(response.read())
deb_files.append(filename)
deb_files.extend([
package for package in packages if package.endswith(".deb")
and os.path.exists(package)
])
if deb_files:
debfile.install(deb_files)
packages = packages.difference(online_files, deb_files)
if packages:
if args.dist:
args.dist = "--target-release " + args.dist
command = "/usr/bin/apt {} {} {} {} --auto-remove install "
command += " ".join(packages)
command = command.format(args.yes, args.noauth, args.recommends,
args.dist)
perform.execute(command, root=True, log=True)
def purgeorphans(args):
"""Purge orphaned libraries (not required by installed packages)"""
# Deborphans does not require root, but dpkg does,
# so build up the orphans list first, then pass that to dpkg.
util.requires_package("deborphan")
packages = ""
for package in perform.execute("deborphan", pipe=True):
packages += " " + package.strip()
if packages:
command = "/usr/bin/apt-get --auto-remove purge {} {}"
command = command.format(args.yes, packages)
perform.execute(command, root=True, log=True)
def autodownload(args):
"""Do an update followed by a download of all updated packages"""
util.do_update(args.simulate)
command = ("/usr/bin/apt-get --download-only --show-upgraded --assume-yes "
"--force-yes dist-upgrade")
perform.execute(command, root=True)
if not args.simulate:
upgradable_packages = util.upgradable()
if upgradable_packages:
util.do_describe(upgradable_packages, verbose)
else:
print("no upgradable packages")
util.show_package_versions()
def installsuggested(args):
"""Install a package and its Suggests dependencies"""
cache = apt.cache.Cache()
package = util.package_exists(cache, args.package,
ignore_virtual_packages=True)
dependencies = list(util.extract_dependencies(package, "Suggests"))
for n, dependency in enumerate(dependencies):
dependencies[n] = util.package_exists(cache, dependency).shortname
dependencies = " ".join(dependencies)
command = "/usr/bin/apt-get {} {} {} --auto-remove install {} {}"
command = command.format(args.recommends, args.yes, args.noauth,
dependencies, args.package)
perform.execute(command, root=True, log=True)
def installsuggested(args):
"""Install a package and its Suggests dependencies"""
cache = apt.cache.Cache()
package = util.package_exists(cache, args.package,
ignore_virtual_packages=True)
dependencies = list(util.extract_dependencies(package, "Suggests"))
for n, dependency in enumerate(dependencies):
dependencies[n] = util.package_exists(cache, dependency).shortname
dependencies = " ".join(dependencies)
command = "/usr/bin/apt-get {} {} {} --auto-remove install {} {}"
command = command.format(args.recommends, args.yes, args.noauth,
dependencies, args.package)
perform.execute(command, root=True, log=True)
def autodownload(args):
"""Do an update followed by a download of all updated packages"""
util.do_update(args.simulate)
command = ("/usr/bin/apt-get --download-only --show-upgraded --assume-yes "
"--force-yes dist-upgrade")
perform.execute(command, root=True)
if not args.simulate:
upgradable_packages = util.upgradable()
if upgradable_packages:
util.do_describe(upgradable_packages, args.verbose)
else:
print("no upgradable packages")
util.show_package_versions()
def purgeremoved(args):
"""Purge all packages marked as deinstall"""
packages = ""
cmd = (
"dpkg-query --show "
"--showformat='${Package}:${Architecture}\t${Status}\n' | "
"grep -E \"deinstall ok config-files\" | cut -f 1 "
)
packages = perform.execute(cmd, pipe=True)
if packages:
packages = " ".join(packages)
packages = " ".join(packages.split())
perform.execute("/usr/bin/apt-get purge " + packages,
root=True, log=True)
def count_upgrades():
"""Return as a string the number of new upgrades since last update."""
ifile = tempfile.mkstemp()[1]
# Use langC in the following since it uses a grep.
perform.execute(gen_installed_command_str() + " > " + ifile, langC=True)
command = ("join %s %s |"
"awk '$2 != $3 {print}' | sort -k 1b,1 | join - %s |"
"awk '$4 != $3 {print}' | wc -l | awk '{print $1}' ") % \
(previous_file, available_file, ifile)
# 090425 Use langC=True to work with change from coreutils 6.10 to 7.2
count = perform.execute(command, pipe=True, langC=True).read().split()[0]
if os.path.exists(ifile):
os.remove(ifile)
return count
def install(args):
"""Package installer
notes:
* specifying a .deb file will also try to satisfy that deb's dependencies;
* one can specify multiple files with --fileinput option
* specifying a url will try fetch the file from the internet, and keep it
in "~/.wajig/$HOSTNAME"
example:
$ wajig install a b_1.0_all.deb http://example.com/c_1.0_all.deb
Assuming there's no errors, the command will install 3 packages named
'a', 'b', and 'c''"""
packages = util.consolidate_package_names(args)
online_files = [package for package in packages
if package.startswith(("http://", "ftp://"))]
deb_files = list()
for package in online_files:
if not package.endswith(".deb"):
print("A valied .deb file should have a '.deb' extension")
continue
filename = os.path.join(util.init_dir, package.split("/")[-1])
try:
response = urllib.request.urlopen(package)
except urllib.error.HTTPError as error:
print("{}; is '{}' the correct url?".format(error.reason, package))
else:
with open(filename, "wb") as f:
f.write(response.read())
deb_files.append(filename)
deb_files.extend([package for package in packages
if package.endswith(".deb")
and os.path.exists(package)])
if deb_files:
debfile.install(deb_files, args)
packages = packages.difference(online_files, deb_files)
if packages:
if args.dist:
args.dist = "--target-release " + args.dist
command = "/usr/bin/apt-get {} {} {} {} --auto-remove install "
command += " ".join(packages)
command = command.format(args.yes, args.noauth, args.recommends,
args.dist)
perform.execute(command, root=True, log=True)
def count_upgrades():
"""Return as a string the number of new upgrades since last update."""
ifile = tempfile.mkstemp()[1]
# Use langC in the following since it uses a grep.
perform.execute(gen_installed_command_str() + " > " + ifile, langC=True)
command = ("join %s %s |"
"awk '$2 != $3 {print}' | sort -k 1b,1 | join - %s |"
"awk '$4 != $3 {print}' | wc -l | awk '{print $1}' ") % \
(previous_file, available_file, ifile)
# 090425 Use langC=True to work with change from coreutils 6.10 to 7.2
count = perform.execute(command, pipe=True,
langC=True).read().split()[0]
if os.path.exists(ifile):
os.remove(ifile)
return count
def listfiles(args):
"""List the files that are supplied by the named package"""
if args.package.endswith(".deb"):
perform.execute("dpkg --contents " + args.package)
return
try:
output = perform.execute(
"dpkg --listfiles " + args.package, getoutput=True
)
except subprocess.CalledProcessError:
if shutil.which("apt-file"):
perform.execute("apt-file list --regexp ^{}$".format(args.package))
else:
for line in output.decode().strip().split('\n'):
print(line)
def whichpackage(args):
"""Search for files matching a given pattern within packages
Note: if no match is found, the apt-file repository is checked"""
try:
out = perform.execute("dpkg --search " + args.pattern, getoutput=True)
except subprocess.CalledProcessError:
util.requires_package("apt-file")
perform.execute("apt-file search " + args.pattern)
else:
try:
print(out.decode().strip())
# will get here when on --simulate mode
except AttributeError:
pass
def finish_log(old_log):
ts = datetime.strftime(datetime.now(), '%Y-%m-%dT%H:%M:%S')
# Generate new list of installed and compare to old
lf = open(log_file, "a")
new_iter = perform.execute(gen_installed_command_str(),
langC=True,
pipe=True)
old_iter = open(old_log)
for o in old_iter:
o = o.strip().split(" ")
n = new_iter.__next__().strip().split(" ")
while o[0] != n[0]:
if o[0] < n[0]:
lf.write("{0} {1} {2} {3}\n".format(ts, "remove", o[0], o[1]))
o = old_iter.__next__().strip().split(" ")
elif o[0] > n[0]:
lf.write("{0} {1} {2} {3}\n".format(ts, "install", n[0], n[1]))
n = new_iter.__next__().strip().split(" ")
if o[1] != n[1]:
old_version = o[1].split(".") # for a more accurate comparison
new_version = n[1].split(".") # same
if old_version > new_version:
lf.write("{0} {1} {2} {3}\n".format(ts, "downgrade", n[0],
n[1]))
else:
lf.write("{0} {1} {2} {3}\n".format(ts, "upgrade", n[0], n[1]))
os.remove(old_log)
def backup_before_upgrade(packages, distupgrade=False):
"""Backup packages before a (dist)upgrade.
This optional functionality helps recovery in case of trouble caused
by the newly-installed packages. The packages are by default stored
in a directory named like ~/.wajig/hostname/backups/2010-09-21_09h21."""
date = time.strftime("%Y-%m-%d_%Hh%M", time.localtime())
target = os.path.join(init_dir, "backups", date)
if not os.path.exists(target):
os.makedirs(target)
os.chdir(target)
print("The packages will saved in", target)
for package in packages:
command = "fakeroot -u dpkg-repack " + package
perform.execute(command)
def finish_log(old_log):
ts = datetime.strftime(datetime.now(), '%Y-%m-%dT%H:%M:%S')
# Generate new list of installed and compare to old
lf = open(log_file, "a")
new_iter = perform.execute(gen_installed_command_str(),
langC=True, pipe=True)
old_iter = open(old_log)
for o in old_iter:
o = o.strip().split(" ")
n = new_iter.__next__().strip().split(" ")
while o[0] != n[0]:
if o[0] < n[0]:
lf.write("{0} {1} {2} {3}\n".format(ts, "remove", o[0], o[1]))
o = old_iter.__next__().strip().split(" ")
elif o[0] > n[0]:
lf.write("{0} {1} {2} {3}\n".format(ts, "install", n[0], n[1]))
n = new_iter.__next__().strip().split(" ")
if o[1] != n[1]:
old_version = o[1].split(".") # for a more accurate comparison
new_version = n[1].split(".") # same
if old_version > new_version:
lf.write("{0} {1} {2} {3}\n".format(ts, "downgrade", n[0], n[1]))
else:
lf.write("{0} {1} {2} {3}\n".format(ts, "upgrade", n[0], n[1]))
os.remove(old_log)
def backup_before_upgrade(packages):
"""Backup packages before a (dist)upgrade.
This optional functionality helps recovery in case of trouble caused
by the newly-installed packages. The packages are by default stored
in a directory named like ~/.wajig/hostname/backups/2010-09-21_09h21."""
date = time.strftime("%Y-%m-%d_%Hh%M", time.localtime())
target = os.path.join(init_dir, "backups", date)
if not os.path.exists(target):
os.makedirs(target)
os.chdir(target)
print("The packages will saved in", target)
for package in packages:
command = "fakeroot -u dpkg-repack " + package
perform.execute(command)
def execute():
rospy.init_node("pih_Master")
myCommandAPI = Cmd_API()
myStateAPI = State_API()
"""
count = 0
while count<500:
arm_controller.lock_rarm(myCommandAPI,myStateAPI)
count +=1
"""
#print myStateAPI.get_rarm_pose(myCommandAPI)
print "-------------STARTING-------------"
start.execute(myStateAPI, myCommandAPI)
print "-------------LEARNING-------------"
#learn.execute(myStateAPI, myCommandAPI)
print "-------------PERFORMING-------------"
perform.execute(myStateAPI,myCommandAPI, learn.execute(myStateAPI, myCommandAPI))
def upgradesecurity(args):
"""Do a security upgrade"""
sources_list = tempfile.mkstemp(".security", "wajig.", "/tmp")[1]
sources_file = open(sources_list, "w")
# check dist
sources_file.write("deb http://security.debian.org/ " +\
"testing/updates main contrib non-free\n")
sources_file.close()
command = ("/usr/bin/apt-get --no-list-cleanup --option Dir::Etc::SourceList="
"{} update")
command = command.format(sources_list)
perform.execute(command, root=True)
command = "/usr/bin/apt-get --option Dir::Etc::SourceList={} upgrade"
command = command.format(sources_list)
perform.execute(command, root=True, log=True)
if os.path.exists(sources_list):
os.remove(sources_list)
def execute():
rospy.init_node("pih_Master")
myCommandAPI = Cmd_API()
myStateAPI = State_API()
"""
count = 0
while count<500:
arm_controller.lock_rarm(myCommandAPI,myStateAPI)
count +=1
"""
#print myStateAPI.get_rarm_pose(myCommandAPI)
print "-------------STARTING-------------"
start.execute(myStateAPI, myCommandAPI)
print "-------------LEARNING-------------"
#learn.execute(myStateAPI, myCommandAPI)
print "-------------PERFORMING-------------"
perform.execute(myStateAPI, myCommandAPI,
learn.execute(myStateAPI, myCommandAPI))
def do_listnames(pattern=False, pipe=False):
# If user can't access /etc/apt/sources.list then must do this with
# sudo or else most packages will not be found.
needsudo = not os.access("/etc/apt/sources.list", os.R_OK)
if pattern:
command = "apt-cache pkgnames | grep -- " + pattern \
+ " | sort -k 1b,1"
else:
command = "apt-cache pkgnames | sort -k 1b,1"
# Start fix for Bug #292581 - pre-run command to check for no output
results = perform.execute(command, root=needsudo, pipe=True)
if results:
lines = results.readlines()
if lines:
return perform.execute(command, root=needsudo, pipe=pipe)
else:
sys.exit(1)
