class PkgDesc(object):
"""Print package description from the repository
"""
def __init__(self, name, repo, paint):
self.name = name
self.repo = repo
self.paint = paint
self.meta = _meta_
self.msg = Msg()
self.COLOR = ""
self.lib = ""
color_text = {
"red": self.meta.color["RED"],
"green": self.meta.color["GREEN"],
"yellow": self.meta.color["YELLOW"],
"cyan": self.meta.color["CYAN"],
"grey": self.meta.color["GREY"],
"": ""
}
self.COLOR = color_text[self.paint]
if self.repo in self.meta.repositories and self.repo != "sbo":
self.lib = self.meta.lib_path + "{0}_repo/PACKAGES.TXT".format(
self.repo)
def view(self):
"""Print package description by repository
"""
print("") # new line at start
description, count = "", 0
if self.repo == "sbo":
description = SBoGrep(self.name).description()
else:
PACKAGES_TXT = Utils().read_file(self.lib)
for line in PACKAGES_TXT.splitlines():
if line.startswith(self.name + ":"):
description += line[len(self.name) + 2:] + "\n"
count += 1
if count == 11:
break
if description:
print("{0}{1}{2}".format(self.COLOR, description,
self.meta.color["ENDC"]))
else:
self.msg.pkg_not_found("", self.name, "No matching", "\n")
raise SystemExit(1)
if description and self.repo == "sbo":
print("")
class PkgDesc(object):
"""Print package description from the repository
"""
def __init__(self, name, repo, paint):
self.name = name
self.repo = repo
self.paint = paint
self.meta = _meta_
self.msg = Msg()
self.COLOR = ""
self.lib = ""
color_text = {
"red": self.meta.color["RED"],
"green": self.meta.color["GREEN"],
"yellow": self.meta.color["YELLOW"],
"cyan": self.meta.color["CYAN"],
"grey": self.meta.color["GREY"],
"": ""
}
self.COLOR = color_text[self.paint]
if self.repo in self.meta.repositories and self.repo != "sbo":
self.lib = self.meta.lib_path + "{0}_repo/PACKAGES.TXT".format(
self.repo)
def view(self):
"""Print package description by repository
"""
print("") # new line at start
description, count = "", 0
if self.repo == "sbo":
description = SBoGrep(self.name).description()
else:
PACKAGES_TXT = Utils().read_file(self.lib)
for line in PACKAGES_TXT.splitlines():
if line.startswith(self.name + ":"):
description += line[len(self.name) + 2:] + "\n"
count += 1
if count == 11:
break
if description:
print("{0}{1}{2}".format(self.COLOR, description,
self.meta.color["ENDC"]))
else:
self.msg.pkg_not_found("", self.name, "No matching", "\n")
raise SystemExit(1)
if description and self.repo == "sbo":
print("")
class BuildPackage(object):
"""Build SBo packages from source
"""
def __init__(self, script, sources, path, auto):
self.script = script
self.sources = sources
self.path = path
self.auto = auto
self.meta = _meta_
self.msg = Msg()
self._SOURCES = self.meta.SBo_SOURCES
self.prgnam = self.script[:-7]
self.log_file = "build_{0}_log".format(self.prgnam)
self.sbo_logs = self.meta.log_path + "sbo/"
self.build_logs = self.sbo_logs + "build_logs/"
self.start_log_time = time.strftime("%H:%M:%S")
self.start_time = time.time()
if not os.path.exists(self.meta.log_path):
os.mkdir(self.meta.log_path)
if not os.path.exists(self.sbo_logs):
os.mkdir(self.sbo_logs)
if not os.path.exists(self.build_logs):
os.mkdir(self.build_logs)
def build(self):
"""
Build package from source and create log
file in path /var/log/slpkg/sbo/build_logs/.
Also check md5sum calculates.
"""
try:
self._delete_dir()
try:
tar = tarfile.open(self.script)
except Exception as err:
print err
raise SystemExit()
tar.extractall()
tar.close()
self._makeflags()
self._delete_sbo_tar_gz()
self._create_md5_dict()
if not self.auto:
os.chdir(self._SOURCES)
for src in self.sources:
if not os.path.isfile(src):
continue
# fix build sources with spaces
src = src.replace("%20", " ")
check_md5(self.sbo_md5[src], src)
# copy source and fix passing char '+' from file name
shutil.copy2(src.replace("%2B", "+"), self.path + self.prgnam)
os.chdir(self.path + self.prgnam)
# change permissions
subprocess.call("chmod +x {0}.SlackBuild".format(self.prgnam),
shell=True)
pass_var = self._pass_variable()
if self.meta.sbo_build_log in ["on", "ON"]:
if os.path.isfile(self.build_logs + self.log_file):
os.remove(self.build_logs + self.log_file)
# start log write
log_head(self.build_logs, self.log_file, self.start_log_time)
subprocess.Popen("{0} ./{1}.SlackBuild 2>&1 | tee -a "
"{2}{3}".format(" ".join(pass_var),
self.prgnam, self.build_logs,
self.log_file),
shell=True,
stdout=sys.stdout).communicate()
sum_time = build_time(self.start_time)
# write end in log file
log_end(self.build_logs, self.log_file, sum_time)
print("Total build time for package {0} : {1}\n".format(
self.prgnam, sum_time))
else:
subprocess.call("{0} ./{1}.SlackBuild".format(
" ".join(pass_var), self.prgnam),
shell=True)
os.chdir(self.path)
except KeyboardInterrupt: # (OSError, IOError):
self.msg.pkg_not_found("\n", self.prgnam, "Wrong file", "\n")
def _create_md5_dict(self):
"""Create md5 dictionary per source
"""
self.sbo_md5 = {}
md5_lists = SBoGrep(self.prgnam).checksum()
for src, md5 in zip(self.sources, md5_lists):
self.sbo_md5[src] = md5
def _makeflags(self):
"""Set variable MAKEFLAGS with the numbers of
processors
"""
if self.meta.makeflags in ["on", "ON"]:
cpus = multiprocessing.cpu_count()
os.environ["MAKEFLAGS"] = "-j{0}".format(cpus)
def _pass_variable(self):
"""Return enviroment variables
"""
pass_var = []
for var in os.environ.keys():
expVAR = var.split("_")
if expVAR[0] == self.prgnam.upper() and expVAR[1] != "PATH":
pass_var.append("{0}={1}".format(expVAR[1], os.environ[var]))
return pass_var
def _delete_sbo_tar_gz(self):
"""Delete slackbuild tar.gz file after untar
"""
if not self.auto and os.path.isfile(self.meta.build_path +
self.script):
os.remove(self.meta.build_path + self.script)
def _delete_dir(self):
"""Delete old folder if exists before start build
"""
if not self.auto and os.path.isdir(self.meta.build_path + self.prgnam):
shutil.rmtree(self.meta.build_path + self.prgnam)
class SBoNetwork(object):
"""View SBo site in terminal and also read, build or
install packages
"""
def __init__(self, name, flag):
self.name = name
self.flag = flag
self.meta = _meta_
self.msg = Msg()
self.arch = SBoArch().get()
self.comp_tar = ".tar.gz"
self.choice = ""
self.FAULT = ""
self.green = self.meta.color["GREEN"]
self.red = self.meta.color["RED"]
self.yellow = self.meta.color["YELLOW"]
self.cyan = self.meta.color["CYAN"]
self.grey = self.meta.color["GREY"]
self.endc = self.meta.color["ENDC"]
self.build_folder = self.meta.build_path
self._SOURCES = self.meta._SBo_SOURCES
self.msg.reading()
self.data = SBoGrep(name="").names()
self.case_insensitive()
if "--checklist" in self.flag:
self.with_checklist()
grep = SBoGrep(self.name)
self.sbo_files = grep.files()
self.blacklist = BlackList().packages(pkgs=self.data, repo="sbo")
self.sbo_url = sbo_search_pkg(self.name)
if self.sbo_url:
self.sbo_desc = grep.description()[len(self.name) + 2:-1]
self.source_dwn = grep.source().split()
self.sbo_req = grep.requires()
self.sbo_dwn = SBoLink(self.sbo_url).tar_gz()
self.sbo_version = grep.version()
self.dwn_srcs = self.sbo_dwn.split() + self.source_dwn
if "--checklist" not in self.flag or not self.sbo_url and self.name:
self.msg.done()
def view(self):
"""View SlackBuild package, read or install them
from slackbuilds.org
"""
if self.sbo_url and self.name not in self.blacklist:
self.prgnam = ("{0}-{1}".format(self.name, self.sbo_version))
self.view_sbo()
while True:
self.read_choice()
choice = {
"r": self.choice_README,
"R": self.choice_README,
"s": self.choice_SlackBuild,
"S": self.choice_SlackBuild,
"f": self.choice_info,
"F": self.choice_info,
"o": self.choice_doinst,
"O": self.choice_doinst,
"d": self.choice_download,
"D": self.choice_download,
"download": self.choice_download,
"b": self.choice_build,
"B": self.choice_build,
"build": self.choice_build,
"i": self.choice_install,
"I": self.choice_install,
"install": self.choice_install,
"c": self.choice_clear_screen,
"C": self.choice_clear_screen,
"clear": self.choice_clear_screen,
"q": self.choice_quit,
"quit": self.choice_quit,
"Q": self.choice_quit
}
try:
choice[self.choice]()
except KeyError:
pass
else:
self.msg.pkg_not_found("\n", self.name, "Can't view", "\n")
def case_insensitive(self):
"""Matching packages distinguish between uppercase and
lowercase
"""
if "--case-ins" in self.flag:
data_dict = Utils().case_sensitive(self.data)
for key, value in data_dict.iteritems():
if key == self.name.lower():
self.name = value
def read_choice(self):
"""Return choice
"""
commands = {
"r": "README",
"R": "README",
"s": "{0}.SlackBuild".format(self.name),
"S": "{0}.SlackBuild".format(self.name),
"f": "{0}.info".format(self.name),
"F": "{0}.info".format(self.name),
"o": "doinst.sh",
"O": "doinst.sh",
"d": "download",
"D": "download",
"download": "download",
"b": "build",
"B": "build",
"build": "build",
"i": "install",
"I": "install",
"install": "install",
"c": "clear",
"C": "clear",
"clear": "clear",
"q": "quit",
"quit": "quit",
"Q": "quit"
}
try:
message = " Choose an option > "
self.choice = raw_input("{0}{1}{2}".format(self.grey, message,
self.endc))
except EOFError:
print("")
raise SystemExit()
try:
sys.stdout.write("{0}\x1b[1A{1}{2}{3}\n".format(
" " * len(message), self.cyan, commands[self.choice],
self.endc))
sys.stdout.flush()
except KeyError:
pass
def choice_README(self):
"""View README file
"""
README = ReadSBo(self.sbo_url).readme("README")
fill = self.fill_pager(README)
self.pager(README + fill)
def choice_SlackBuild(self):
"""View .SlackBuild file
"""
SlackBuild = ReadSBo(self.sbo_url).slackbuild(self.name, ".SlackBuild")
fill = self.fill_pager(SlackBuild)
self.pager(SlackBuild + fill)
def choice_info(self):
"""View .info file
"""
info = ReadSBo(self.sbo_url).info(self.name, ".info")
fill = self.fill_pager(info)
self.pager(info + fill)
def choice_doinst(self):
"""View doinst.sh file
"""
if "doinst.sh" in self.sbo_files.split():
doinst_sh = ReadSBo(self.sbo_url).doinst("doinst.sh")
fill = self.fill_pager(doinst_sh)
self.pager(doinst_sh + fill)
def choice_download(self):
"""Download script.tar.gz and sources
"""
Download(path="", url=self.dwn_srcs, repo="sbo").start()
raise SystemExit()
def choice_build(self):
"""Build package
"""
self.build()
delete(self.build_folder)
raise SystemExit()
def choice_install(self):
"""Download, build and install package
"""
if not find_package(self.prgnam, self.meta.pkg_path):
self.build()
self.install()
delete(self.build_folder)
raise SystemExit()
else:
self.msg.template(78)
self.msg.pkg_found(self.prgnam)
self.msg.template(78)
raise SystemExit()
def choice_clear_screen(self):
"""Clear screen
"""
os.system("clear")
self.view()
def choice_quit(self):
"""Quit from choices
"""
raise SystemExit()
def view_sbo(self):
"""View slackbuild.org
"""
sbo_url = self.sbo_url.replace("/slackbuilds/", "/repository/")
br1, br2, fix_sp = "", "", " "
if self.meta.use_colors in ["off", "OFF"]:
br1 = "("
br2 = ")"
fix_sp = ""
print("") # new line at start
self.msg.template(78)
print("| {0}{1}SlackBuilds Repository{2}".format(" " * 28, self.grey,
self.endc))
self.msg.template(78)
print("| {0} > {1} > {2}{3}{4}".format(slack_ver(),
sbo_url.split("/")[-3].title(),
self.cyan, self.name, self.endc))
self.msg.template(78)
print("| {0}Package url{1}: {2}".format(self.green, self.endc, sbo_url))
self.msg.template(78)
print("| {0}Description: {1}{2}".format(self.green,
self.endc, self.sbo_desc))
print("| {0}SlackBuild: {1}{2}".format(self.green, self.endc,
self.sbo_dwn.split("/")[-1]))
print("| {0}Sources: {1}{2}".format(
self.green, self.endc,
(", ".join([src.split("/")[-1] for src in self.source_dwn]))))
print("| {0}Requirements: {1}{2}".format(self.yellow,
self.endc,
", ".join(self.sbo_req)))
self.msg.template(78)
print("| {0}R{1}{2}EADME View the README file".format(
self.red, self.endc, br2))
print("| {0}S{1}{2}lackBuild View the .SlackBuild "
"file".format(self.red, self.endc, br2))
print("| In{0}{1}f{2}{3}o{4} View the .info "
"file".format(br1, self.red, self.endc, br2, fix_sp))
if "doinst.sh" in self.sbo_files.split():
print("| D{0}{1}o{2}{3}inst.sh{4} View the doinst.sh "
"file".format(br1, self.red, self.endc, br2, fix_sp))
print("| {0}D{1}{2}ownload Download this package".format(
self.red, self.endc, br2))
print("| {0}B{1}{2}uild Download and build".format(
self.red, self.endc, br2))
print("| {0}I{1}{2}nstall Download/Build/Install".format(
self.red, self.endc, br2))
print("| {0}C{1}{2}lear Clear screen".format(self.red,
self.endc,
br2))
print("| {0}Q{1}{2}uit Quit".format(self.red,
self.endc, br2))
self.msg.template(78)
def with_checklist(self):
"""Using dialog and checklist option
"""
data = []
if self.name == "ALL":
data = self.data
else:
for name in self.data:
if self.name in name:
data.append(name)
if data:
text = "Press 'spacebar' to choose SlackBuild for view"
title = " SlackBuilds.org "
backtitle = "{0} {1}".format(_meta_.__all__, _meta_.__version__)
status = False
pkg = DialogUtil(data, text, title, backtitle, status).checklist()
if pkg and len(pkg) > 1:
print("\nslpkg: Error: Choose only one package")
raise SystemExit()
if pkg is None:
raise SystemExit()
self.name = "".join(pkg)
os.system("clear")
def pager(self, text):
"""Read text
"""
pydoc.pager(text)
def fill_pager(self, page):
"""Fix pager spaces
"""
tty_size = os.popen("stty size", "r").read().split()
rows = int(tty_size[0]) - 1
lines = sum(1 for line in page.splitlines())
diff = rows - lines
fill = "\n" * diff
if diff > 0:
return fill
else:
return ""
def error_uns(self):
"""Check if package supported by arch
before proceed to install
"""
self.FAULT = ""
UNST = ["UNSUPPORTED", "UNTESTED"]
if "".join(self.source_dwn) in UNST:
self.FAULT = "".join(self.source_dwn)
def build(self):
"""Only build and create Slackware package
"""
self.error_uns()
if self.FAULT:
print("")
self.msg.template(78)
print("| Package {0} {1} {2} {3}".format(self.prgnam, self.red,
self.FAULT, self.endc))
self.msg.template(78)
else:
sources = []
if not os.path.exists(self.meta.build_path):
os.makedirs(self.meta.build_path)
if not os.path.exists(self._SOURCES):
os.makedirs(self._SOURCES)
os.chdir(self.meta.build_path)
Download(self.meta.build_path, self.sbo_dwn.split(),
repo="sbo").start()
Download(self._SOURCES, self.source_dwn, repo="sbo").start()
script = self.sbo_dwn.split("/")[-1]
for src in self.source_dwn:
sources.append(src.split("/")[-1])
BuildPackage(script, sources, self.meta.build_path,
auto=False).build()
slack_package(self.prgnam) # check if build
def install(self):
"""Install SBo package found in /tmp directory.
"""
binary = slack_package(self.prgnam)
print("[ {0}Installing{1} ] --> {2}".format(self.green, self.endc,
self.name))
PackageManager(binary).upgrade(flag="--install-new")
class PackageManager(object):
"""Package manager class for install, upgrade,
reinstall, remove, find and display packages"""
def __init__(self, binary):
self.binary = binary
self.meta = _meta_
self.msg = Msg()
self.skip = []
self.size = 0
self.unit = "Kb"
def install(self, flag):
"""Install Slackware binary packages
"""
for pkg in self.binary:
try:
subprocess.call("installpkg {0} {1}".format(flag, pkg),
shell=True)
check = pkg[:-4].split("/")[-1]
if os.path.isfile(self.meta.pkg_path + check):
print("Completed!\n")
else:
raise SystemExit()
except subprocess.CalledProcessError:
self._not_found("Can't install", self.binary, pkg)
def upgrade(self, flag):
"""Upgrade Slackware binary packages with new
"""
for pkg in self.binary:
try:
subprocess.call("upgradepkg {0} {1}".format(flag, pkg),
shell=True)
check = pkg[:-4].split("/")[-1]
if os.path.isfile(self.meta.pkg_path + check):
print("Completed!\n")
else:
raise SystemExit()
except subprocess.CalledProcessError:
self._not_found("Can't upgrade", self.binary, pkg)
def _not_found(self, message, binary, pkg):
if len(binary) > 1:
bol = eol = ""
else:
bol = eol = "\n"
self.msg.pkg_not_found(bol, pkg, message, eol)
def remove(self, flag, extra):
"""Remove Slackware binary packages
"""
self.flag = flag
self.extra = extra
self.dep_path = self.meta.log_path + "dep/"
dependencies, rmv_list = [], []
self.removed = self._view_removed()
if not self.removed:
print("") # new line at end
else:
msg = "package"
if len(self.removed) > 1:
msg = msg + "s"
try:
if self.meta.default_answer in ["y", "Y"]:
remove_pkg = self.meta.default_answer
else:
remove_pkg = raw_input(
"\nAre you sure to remove {0} {1} [y/N]? ".format(
str(len(self.removed)), msg))
except EOFError:
print("") # new line at exit
raise SystemExit()
if remove_pkg in ["y", "Y"]:
self._check_if_used(self.binary)
for rmv in self.removed:
# If package build and install with "slpkg -s sbo <package>"
# then look log file for dependencies in /var/log/slpkg/dep,
# read and remove all else remove only the package.
if (os.path.isfile(self.dep_path + rmv) and
self.meta.del_deps in ["on", "ON"] or
"--deps" in self.extra):
dependencies = self._view_deps(self.dep_path, rmv)
if dependencies and self._rmv_deps_answer() in ["y",
"Y"]:
rmv_list += self._rmv_deps(dependencies, rmv)
else:
rmv_list += self._rmv_pkg(rmv)
else:
rmv_list += self._rmv_pkg(rmv)
# Prints all removed packages
self._reference_rmvs(rmv_list)
def _rmv_deps_answer(self):
"""Remove dependencies answer
"""
if self.meta.remove_deps_answer in ["y", "Y"]:
remove_dep = self.meta.remove_deps_answer
else:
try:
remove_dep = raw_input(
"\nRemove dependencies (maybe used by "
"other packages) [y/N]? ")
print("")
except EOFError:
print("") # new line at exit
raise SystemExit()
return remove_dep
def _get_removed(self):
"""Manage removed packages by extra options
"""
removed, packages = [], []
if "--tag" in self.extra:
for pkg in find_package("", self.meta.pkg_path):
for tag in self.binary:
if pkg.endswith(tag):
removed.append(split_package(pkg)[0])
packages.append(pkg)
if not removed:
self.msg.pkg_not_found("", "'tag'", "Can't remove", "")
else:
for pkg in self.binary:
name = GetFromInstalled(pkg).name()
ver = GetFromInstalled(pkg).version()
package = find_package("{0}{1}{2}".format(
name, ver, self.meta.sp), self.meta.pkg_path)
if pkg and name == pkg:
removed.append(pkg)
packages.append(package[0])
else:
self.msg.pkg_not_found("", pkg, "Can't remove", "")
return removed, packages
def _view_removed(self):
"""View packages before removed
"""
print("\nPackages with name matching [ {0}{1}{2} ]\n".format(
self.meta.color["CYAN"], ", ".join(self.binary),
self.meta.color["ENDC"]))
removed, packages = self._get_removed()
if packages and "--checklist" in self.extra:
removed = []
data = packages
text = "Press 'spacebar' to unchoose packages from remove"
title = "Remove"
backtitle = "{0} {1}".format(self.meta.__all__,
self.meta.__version__)
status = True
pkgs = DialogUtil(data, text, title, backtitle, status).checklist()
if pkgs:
for rmv in pkgs:
removed.append(split_package(rmv)[0])
self.meta.default_answer = "y"
else:
for rmv, pkg in zip(removed, packages):
print("[ {0}delete{1} ] --> {2}".format(
self.meta.color["RED"], self.meta.color["ENDC"], pkg))
self._sizes(pkg)
self._calc_sizes()
self._remove_summary()
return removed
def _calc_sizes(self):
"""Package size calculation
"""
if self.size > 1024:
self.unit = "Mb"
self.size = (self.size / 1024)
if self.size > 1024:
self.unit = "Gb"
self.size = (self.size / 1024)
def _remove_summary(self):
"""Removed packge size summary
"""
if self.size > 0:
print("\nRemoved summary")
print("=" * 79)
print("{0}Size of removed packages {1} {2}.{3}".format(
self.meta.color["GREY"], round(self.size, 2), self.unit,
self.meta.color["ENDC"]))
def _view_deps(self, path, package):
"""View dependencies before remove
"""
self.size = 0
packages = []
dependencies = (Utils().read_file(path + package)).splitlines()
for dep in dependencies:
if GetFromInstalled(dep).name():
ver = GetFromInstalled(dep).version()
packages.append(dep + ver)
else:
dependencies.remove(dep)
if packages:
if "--checklist" in self.extra:
deps, dependencies = [], []
data = packages
text = "Found dependencies for package {0}".format(package)
title = "Remove"
backtitle = "{0} {1}".format(self.meta.__all__,
self.meta.__version__)
status = True
deps = DialogUtil(data, text, title, backtitle,
status).checklist()
for d in deps:
dependencies.append("-".join(d.split("-")[:-1]))
self.meta.remove_deps_answer = "y"
else:
print("") # new line at start
self.msg.template(78)
print("| Found dependencies for package {0}:".format(package))
self.msg.template(78)
for pkg in packages:
find = find_package(pkg + self.meta.sp, self.meta.pkg_path)
self._sizes(find[0])
print("| {0}{1}{2}".format(self.meta.color["RED"], pkg,
self.meta.color["ENDC"]))
self.msg.template(78)
self._calc_sizes()
print("| {0}Size of removed dependencies {1} {2}{3}".format(
self.meta.color["GREY"], round(self.size, 2), self.unit,
self.meta.color["ENDC"]))
self.msg.template(78)
return dependencies
def _removepkg(self, package):
"""removepkg Slackware command
"""
try:
subprocess.call("removepkg {0} {1}".format(self.flag, package),
shell=True)
if os.path.isfile(self.dep_path + package):
os.remove(self.dep_path + package) # remove log
except subprocess.CalledProcessError as er:
print(er)
raise SystemExit()
def _rmv_deps(self, dependencies, package):
"""Remove dependencies
"""
removes = []
dependencies.append(package)
self._check_if_used(dependencies)
for dep in dependencies:
if dep not in self.skip and GetFromInstalled(dep).name():
ver = GetFromInstalled(dep).version()
removes.append(dep + ver)
self._removepkg(dep)
return removes
def _rmv_pkg(self, package):
"""Remove one signle package
"""
removes = []
if GetFromInstalled(package).name() and package not in self.skip:
ver = GetFromInstalled(package).version()
removes.append(package + ver)
self._removepkg(package)
return removes
def _skip_remove(self):
"""Skip packages from remove
"""
if "--checklist" not in self.extra:
self.msg.template(78)
print("| Insert packages to exception remove:")
self.msg.template(78)
try:
self.skip = raw_input(" > ").split()
except EOFError:
print("")
raise SystemExit()
for s in self.skip:
if s in self.removed:
self.removed.remove(s)
def _check_if_used(self, removes):
"""Check package if dependencies for another package
before removed"""
if "--check-deps" in self.extra:
package, dependency, pkg_dep = [], [], []
for pkg in find_package("", self.dep_path):
deps = Utils().read_file(self.dep_path + pkg)
for rmv in removes:
if GetFromInstalled(rmv).name() and rmv in deps.split():
pkg_dep.append(
"{0} is dependency of the package --> {1}".format(
rmv, pkg))
package.append(pkg)
dependency.append(rmv)
if package:
if "--checklist" in self.extra:
data = pkg_dep
text = ("Press 'spacebar' to choose packages to exception "
"remove")
title = "!!! WARNING !!!"
backtitle = "{0} {1}".format(self.meta.__all__,
self.meta.__version__)
status = False
choose = DialogUtil(data, text, title, backtitle,
status).checklist()
for pkg in choose:
self.skip.append(pkg.split()[0])
else:
self.msg.template(78)
print("| {0}{1}{2}".format(
self.meta.color["RED"], " " * 30 + "!!! WARNING !!!",
self.meta.color["ENDC"]))
self.msg.template(78)
for p, d in zip(package, dependency):
print("| {0}{1}{2} is dependency of the package --> "
"{3}{4}{5}".format(self.meta.color["YELLOW"], d,
self.meta.color["ENDC"],
self.meta.color["GREEN"], p,
self.meta.color["ENDC"]))
self.msg.template(78)
self._skip_remove()
def _reference_rmvs(self, removes):
"""Prints all removed packages
"""
print("")
self.msg.template(78)
print("| Total {0} packages removed".format(len(removes)))
self.msg.template(78)
for pkg in removes:
if not GetFromInstalled(pkg).name():
print("| Package {0} removed".format(pkg))
else:
print("| Package {0} not found".format(pkg))
self.msg.template(78)
print("") # new line at end
def find(self, flag):
"""Find installed Slackware packages
"""
matching, pkg_cache, match_cache = 0, "", ""
print("\nPackages with matching name [ {0}{1}{2} ]\n".format(
self.meta.color["CYAN"], ", ".join(self.binary),
self.meta.color["ENDC"]))
for pkg in self.binary:
for match in find_package("", self.meta.pkg_path):
if "--case-ins" in flag:
pkg_cache = pkg.lower()
match_cache = match.lower()
else:
pkg_cache = pkg
match_cache = match
if pkg_cache in match_cache:
matching += 1
print("[ {0}installed{1} ] - {2}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"],
match))
self._sizes(match)
if matching == 0:
message = "Can't find"
self.msg.pkg_not_found("", ", ".join(self.binary), message, "\n")
else:
self._calc_sizes()
print("\nFound summary")
print("=" * 79)
print("{0}Total found {1} matching packages.{2}".format(
self.meta.color["GREY"], matching, self.meta.color["ENDC"]))
print("{0}Size of installed packages {1} {2}.{3}\n".format(
self.meta.color["GREY"], round(self.size, 2), self.unit,
self.meta.color["ENDC"]))
def _sizes(self, package):
"""Package size summary
"""
data = Utils().read_file(self.meta.pkg_path + package)
for line in data.splitlines():
if line.startswith("UNCOMPRESSED PACKAGE SIZE:"):
if "M" in line[26:]:
self.size += float(line[26:-1]) * 1024
else:
self.size += float(line[26:-1])
break
def display(self):
"""Print the Slackware packages contents
"""
for pkg in self.binary:
name = GetFromInstalled(pkg).name()
ver = GetFromInstalled(pkg).version()
find = find_package("{0}{1}{2}".format(name, ver, self.meta.sp),
self.meta.pkg_path)
if find:
package = Utils().read_file(
self.meta.pkg_path + "".join(find))
print(package)
else:
message = "Can't dislpay"
if len(self.binary) > 1:
bol = eol = ""
else:
bol = eol = "\n"
self.msg.pkg_not_found(bol, pkg, message, eol)
def package_list(self, repo, INDEX, installed):
"""List with the installed packages
"""
tty_size = os.popen("stty size", "r").read().split()
row = int(tty_size[0]) - 2
try:
all_installed_names = []
index, page, pkg_list = 0, row, []
r = self.list_lib(repo)
pkg_list = self.list_greps(repo, r)[0]
all_installed_names = self.list_of_installed(repo)
print("")
for pkg in sorted(pkg_list):
if INDEX:
index += 1
pkg = self.list_color_tag(pkg)
print("{0}{1}:{2} {3}".format(
self.meta.color["GREY"], index,
self.meta.color["ENDC"], pkg))
if index == page:
read = raw_input("\nPress {0}Enter{1} to "
"continue... ".format(
self.meta.color["CYAN"],
self.meta.color["ENDC"]))
if read in ["Q", "q"]:
break
print("") # new line after page
page += row
elif installed:
if repo == "sbo":
if pkg in all_installed_names:
print("{0}{1}{2}".format(self.meta.color["GREEN"],
pkg,
self.meta.color["ENDC"]))
else:
if pkg[:-4] in all_installed_names:
print("{0}{1}{2}".format(self.meta.color["GREEN"],
pkg,
self.meta.color["ENDC"]))
else:
print(pkg)
print("") # new line at end
except EOFError:
print("") # new line at exit
raise SystemExit()
def list_greps(self, repo, packages):
"""Grep packages
"""
pkg_list, pkg_size = [], []
for line in packages.splitlines():
if repo == "sbo":
if line.startswith("SLACKBUILD NAME: "):
pkg_list.append(line[17:].strip())
pkg_size.append("0 K")
else:
if line.startswith("PACKAGE NAME: "):
pkg_list.append(line[15:].strip())
if line.startswith("PACKAGE SIZE (compressed): "):
pkg_size.append(line[26:].strip())
if repo == "alien":
return alien_filter(pkg_list, pkg_size)
return pkg_list, pkg_size
def list_lib(self, repo):
"""Return package lists
"""
if repo == "sbo":
if (os.path.isfile(
self.meta.lib_path + "{0}_repo/SLACKBUILDS.TXT".format(
repo))):
packages = Utils().read_file(self.meta.lib_path + "{0}_repo/"
"SLACKBUILDS.TXT".format(repo))
else:
if (os.path.isfile(
self.meta.lib_path + "{0}_repo/PACKAGES.TXT".format(repo))):
packages = Utils().read_file(self.meta.lib_path + "{0}_repo/"
"PACKAGES.TXT".format(repo))
return packages
def list_color_tag(self, pkg):
"""Tag with color installed packages
"""
name = GetFromInstalled(pkg).name()
find = name + self.meta.sp
if pkg.endswith(".txz") or pkg.endswith(".tgz"):
find = pkg[:-4]
if find_package(find, self.meta.pkg_path):
pkg = "{0}{1}{2}".format(self.meta.color["GREEN"], pkg,
self.meta.color["ENDC"])
return pkg
def list_of_installed(self, repo):
"""Return installed packages
"""
all_installed_names = []
all_installed_packages = find_package("", self.meta.pkg_path)
for inst in all_installed_packages:
if repo == "sbo" and inst.endswith("_SBo"):
name = split_package(inst)[0]
all_installed_names.append(name)
else:
all_installed_names.append(inst)
return all_installed_names
class PackageManager(object):
"""Package manager class for install, upgrade,
reinstall, remove, find and display packages"""
def __init__(self, binary):
self.binary = binary
self.meta = _meta_
self.msg = Msg()
self.skip = []
self.size = 0
self.file_size = 0
self.unit = "Kb"
def install(self, flag):
"""Install Slackware binary packages
"""
for pkg in self.binary:
try:
subprocess.call("installpkg {0} {1}".format(flag, pkg),
shell=True)
check = pkg[:-4].split("/")[-1]
if os.path.isfile(self.meta.pkg_path + check):
print("Completed!\n")
else:
raise SystemExit()
except subprocess.CalledProcessError:
self._not_found("Can't install", self.binary, pkg)
raise SystemExit(1)
def upgrade(self, flag):
"""Upgrade Slackware binary packages with new
"""
for pkg in self.binary:
try:
subprocess.call("upgradepkg {0} {1}".format(flag, pkg),
shell=True)
check = pkg[:-4].split("/")[-1]
if os.path.isfile(self.meta.pkg_path + check):
print("Completed!\n")
else:
raise SystemExit()
except subprocess.CalledProcessError:
self._not_found("Can't upgrade", self.binary, pkg)
raise SystemExit(1)
def _not_found(self, message, binary, pkg):
if len(binary) > 1:
bol = eol = ""
else:
bol = eol = "\n"
self.msg.pkg_not_found(bol, pkg, message, eol)
def remove(self, flag, extra):
"""Remove Slackware binary packages
"""
self.flag = flag
self.extra = extra
self.dep_path = self.meta.log_path + "dep/"
dependencies, rmv_list = [], []
self.removed = self._view_removed()
if not self.removed:
print("") # new line at end
else:
msg = "package"
if len(self.removed) > 1:
msg = msg + "s"
try:
if self.meta.default_answer in ["y", "Y"]:
remove_pkg = self.meta.default_answer
else:
remove_pkg = raw_input(
"\nAre you sure to remove {0} {1} [y/N]? ".format(
str(len(self.removed)), msg))
except EOFError:
print("") # new line at exit
raise SystemExit()
if remove_pkg in ["y", "Y"]:
self._check_if_used(self.binary)
for rmv in self.removed:
# If package build and install with "slpkg -s sbo <package>"
# then look log file for dependencies in /var/log/slpkg/dep,
# read and remove all else remove only the package.
if (os.path.isfile(self.dep_path + rmv) and
self.meta.del_deps in ["on", "ON"] or
os.path.isfile(self.dep_path + rmv) and
"--deps" in self.extra):
dependencies = self._view_deps(self.dep_path, rmv)
if dependencies and self._rmv_deps_answer() in ["y",
"Y"]:
rmv_list += self._rmv_deps(dependencies, rmv)
else:
rmv_list += self._rmv_pkg(rmv)
else:
rmv_list += self._rmv_pkg(rmv)
# Prints all removed packages
self._reference_rmvs(rmv_list)
def _rmv_deps_answer(self):
"""Remove dependencies answer
"""
if self.meta.remove_deps_answer in ["y", "Y"]:
remove_dep = self.meta.remove_deps_answer
else:
try:
remove_dep = raw_input(
"\nRemove dependencies (maybe used by "
"other packages) [y/N]? ")
print("")
except EOFError:
print("") # new line at exit
raise SystemExit()
return remove_dep
def _get_removed(self):
"""Manage removed packages by extra options
"""
removed, packages = [], []
if "--tag" in self.extra:
for pkg in find_package("", self.meta.pkg_path):
for tag in self.binary:
if pkg.endswith(tag):
removed.append(split_package(pkg)[0])
packages.append(pkg)
if not removed:
self.msg.pkg_not_found("", "'tag'", "Can't remove", "\n")
raise SystemExit(1)
else:
for pkg in self.binary:
name = GetFromInstalled(pkg).name()
ver = GetFromInstalled(pkg).version()
package = find_package("{0}{1}{2}".format(
name, ver, self.meta.sp), self.meta.pkg_path)
if pkg and name == pkg:
removed.append(pkg)
packages.append(package[0])
else:
self.msg.pkg_not_found("", pkg, "Can't remove", "\n")
raise SystemExit(1)
return removed, packages
def _view_removed(self):
"""View packages before removed
"""
print("\nPackages with name matching [ {0}{1}{2} ]\n".format(
self.meta.color["CYAN"], ", ".join(self.binary),
self.meta.color["ENDC"]))
removed, packages = self._get_removed()
if packages and "--checklist" in self.extra:
removed = []
text = "Press 'spacebar' to unchoose packages from the remove"
backtitle = "{0} {1}".format(self.meta.__all__,
self.meta.__version__)
status = True
pkgs = DialogUtil(packages, text, " Remove ", backtitle,
status).checklist()
if pkgs:
for rmv in pkgs:
removed.append(split_package(rmv)[0])
self.meta.default_answer = "y"
else:
for rmv, pkg in zip(removed, packages):
print("[ {0}delete{1} ] --> {2}".format(
self.meta.color["RED"], self.meta.color["ENDC"], pkg))
self._sizes(pkg)
self._calc_sizes()
self._remove_summary()
return removed
def _calc_sizes(self):
"""Package size calculation
"""
if self.size > 1024:
self.unit = "Mb"
self.size = (self.size / 1024)
if self.size > 1024:
self.unit = "Gb"
self.size = (self.size / 1024)
def _remove_summary(self):
"""Removed packge size summary
"""
if self.size > 0:
print("\nRemoved summary")
print("=" * 79)
print("{0}Size of removed packages {1} {2}.{3}".format(
self.meta.color["GREY"], round(self.size, 2), self.unit,
self.meta.color["ENDC"]))
def _view_deps(self, path, package):
"""View dependencies before remove
"""
self.size = 0
packages = []
dependencies = (Utils().read_file(path + package)).splitlines()
for dep in dependencies:
if GetFromInstalled(dep).name():
ver = GetFromInstalled(dep).version()
packages.append(dep + ver)
else:
dependencies.remove(dep)
if packages:
if "--checklist" in self.extra:
deps, dependencies = [], []
text = "Found dependencies for the package {0}".format(package)
backtitle = "{0} {1}".format(self.meta.__all__,
self.meta.__version__)
status = True
deps = DialogUtil(packages, text, " Remove ", backtitle,
status).checklist()
for d in deps:
dependencies.append("-".join(d.split("-")[:-1]))
self.meta.remove_deps_answer = "y"
else:
print("") # new line at start
self.msg.template(78)
print("| Found dependencies for the package {0}:".format(
package))
self.msg.template(78)
for pkg in packages:
find = find_package(pkg + self.meta.sp, self.meta.pkg_path)
self._sizes(find[0])
print("| {0}{1}{2}".format(self.meta.color["RED"], pkg,
self.meta.color["ENDC"]))
self.msg.template(78)
self._calc_sizes()
print("| {0}Size of removed dependencies {1} {2}{3}".format(
self.meta.color["GREY"], round(self.size, 2), self.unit,
self.meta.color["ENDC"]))
self.msg.template(78)
return dependencies
def _removepkg(self, package):
"""removepkg Slackware command
"""
try:
subprocess.call("removepkg {0} {1}".format(self.flag, package),
shell=True)
if os.path.isfile(self.dep_path + package):
os.remove(self.dep_path + package) # remove log
except subprocess.CalledProcessError as er:
print(er)
raise SystemExit()
def _rmv_deps(self, dependencies, package):
"""Remove dependencies
"""
removes = []
dependencies.append(package)
self._check_if_used(dependencies)
for dep in dependencies:
if dep not in self.skip and GetFromInstalled(dep).name():
ver = GetFromInstalled(dep).version()
removes.append(dep + ver)
self._removepkg(dep)
return removes
def _rmv_pkg(self, package):
"""Remove one signle package
"""
removes = []
if GetFromInstalled(package).name() and package not in self.skip:
ver = GetFromInstalled(package).version()
removes.append(package + ver)
self._removepkg(package)
return removes
def _skip_remove(self):
"""Skip packages from remove
"""
if "--checklist" not in self.extra:
self.msg.template(78)
print("| Insert packages to exception remove:")
self.msg.template(78)
try:
self.skip = raw_input(" > ").split()
except EOFError:
print("")
raise SystemExit()
for s in self.skip:
if s in self.removed:
self.removed.remove(s)
def _check_if_used(self, removes):
"""Check package if dependencies for another package
before removed"""
if "--check-deps" in self.extra:
package, dependency, pkg_dep = [], [], []
for pkg in find_package("", self.dep_path):
deps = Utils().read_file(self.dep_path + pkg)
for rmv in removes:
if GetFromInstalled(rmv).name() and rmv in deps.split():
pkg_dep.append(
"{0} is dependency of the package --> {1}".format(
rmv, pkg))
package.append(pkg)
dependency.append(rmv)
if package:
if "--checklist" in self.extra:
text = ("Press 'spacebar' to choose packages for the remove"
" exception")
backtitle = "{0} {1}".format(self.meta.__all__,
self.meta.__version__)
status = False
choose = DialogUtil(pkg_dep, text, " !!! WARNING !!! ",
backtitle, status).checklist()
for pkg in choose:
self.skip.append(pkg.split()[0])
else:
self.msg.template(78)
print("| {0}{1}{2}".format(
self.meta.color["RED"], " " * 30 + "!!! WARNING !!!",
self.meta.color["ENDC"]))
self.msg.template(78)
for p, d in zip(package, dependency):
print("| {0}{1}{2} is dependency of the package --> "
"{3}{4}{5}".format(self.meta.color["YELLOW"], d,
self.meta.color["ENDC"],
self.meta.color["GREEN"], p,
self.meta.color["ENDC"]))
self.msg.template(78)
self._skip_remove()
def _reference_rmvs(self, removes):
"""Prints all removed packages
"""
print("")
self.msg.template(78)
msg_pkg = "package"
if len(removes) > 1:
msg_pkg = "packages"
print("| Total {0} {1} removed".format(len(removes), msg_pkg))
self.msg.template(78)
for pkg in removes:
if not GetFromInstalled(pkg).name():
print("| Package {0} removed".format(pkg))
else:
print("| Package {0} not found".format(pkg))
self.msg.template(78)
print("") # new line at end
def find(self, flag):
"""Find installed Slackware packages
"""
matching, pkg_cache, match_cache = 0, "", ""
print("\nPackages with matching name [ {0}{1}{2} ]\n".format(
self.meta.color["CYAN"], ", ".join(self.binary),
self.meta.color["ENDC"]))
for pkg in self.binary:
for match in find_package("", self.meta.pkg_path):
if "--case-ins" in flag:
pkg_cache = pkg.lower()
match_cache = match.lower()
else:
pkg_cache = pkg
match_cache = match
if pkg_cache in match_cache:
matching += 1
self._sizes(match)
print("[ {0}installed{1} ] [ {2} ] - {3}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"],
self.file_size, match))
if matching == 0:
message = "Can't find"
self.msg.pkg_not_found("", ", ".join(self.binary), message, "\n")
raise SystemExit(1)
else:
self._calc_sizes()
print("\nFound summary")
print("=" * 79)
print("{0}Total found {1} matching packages.{2}".format(
self.meta.color["GREY"], matching, self.meta.color["ENDC"]))
print("{0}Size of installed packages {1} {2}.{3}\n".format(
self.meta.color["GREY"], round(self.size, 2), self.unit,
self.meta.color["ENDC"]))
def _sizes(self, package):
"""Package size summary
"""
data = Utils().read_file(self.meta.pkg_path + package)
for line in data.splitlines():
if line.startswith("UNCOMPRESSED PACKAGE SIZE:"):
digit = float((''.join(re.findall(
"[-+]?\d+[\.]?\d*[eE]?[-+]?\d*", line[26:]))))
self.file_size = line[26:].strip()
if "M" in line[26:]:
self.size += digit * 1024
else:
self.size += digit
break
def display(self):
"""Print the Slackware packages contents
"""
for pkg in self.binary:
name = GetFromInstalled(pkg).name()
ver = GetFromInstalled(pkg).version()
find = find_package("{0}{1}{2}".format(name, ver, self.meta.sp),
self.meta.pkg_path)
if find:
package = Utils().read_file(
self.meta.pkg_path + "".join(find))
print(package)
else:
message = "Can't dislpay"
if len(self.binary) > 1:
bol = eol = ""
else:
bol = eol = "\n"
self.msg.pkg_not_found(bol, pkg, message, eol)
raise SystemExit(1)
def package_list(self, repo, name, INDEX, installed):
"""List with the installed packages
"""
tty_size = os.popen("stty size", "r").read().split()
row = int(tty_size[0]) - 2
try:
all_installed_names = []
index, page, pkg_list = 0, row, []
r = self.list_lib(repo)
pkg_list = self.list_greps(repo, r)[0]
all_installed_names = self.list_of_installed(repo, name)
print("")
for pkg in sorted(pkg_list):
pkg = self._splitting_packages(pkg, repo, name)
if installed:
if repo == "sbo":
if pkg in all_installed_names:
pkg = ("{0}{1}{2}".format(self.meta.color["GREEN"],
pkg,
self.meta.color["ENDC"]))
else:
if pkg in all_installed_names:
pkg = ("{0}{1}{2}".format(self.meta.color["GREEN"],
pkg,
self.meta.color["ENDC"]))
if INDEX:
index += 1
pkg = self.list_color_tag(pkg)
print("{0}{1}:{2} {3}".format(
self.meta.color["GREY"], index,
self.meta.color["ENDC"], pkg))
if index == page:
read = raw_input("\nPress {0}Enter{1} to "
"continue... ".format(
self.meta.color["CYAN"],
self.meta.color["ENDC"]))
if read in ["Q", "q"]:
break
print("") # new line after page
page += row
else:
print(pkg)
print("") # new line at end
except EOFError:
print("") # new line at exit
raise SystemExit()
def _splitting_packages(self, pkg, repo, name):
"""Return package name from repositories
"""
if name and repo != "sbo":
pkg = split_package(pkg)[0]
elif not name and repo != "sbo":
pkg = pkg[:-4]
return pkg
def list_greps(self, repo, packages):
"""Grep packages
"""
pkg_list, pkg_size = [], []
for line in packages.splitlines():
if repo == "sbo":
if line.startswith("SLACKBUILD NAME: "):
pkg_list.append(line[17:].strip())
pkg_size.append("0 K")
else:
if line.startswith("PACKAGE NAME: "):
pkg_list.append(line[15:].strip())
if line.startswith("PACKAGE SIZE (compressed): "):
pkg_size.append(line[26:].strip())
if repo == "alien" or repo == "ktown":
return alien_filter(pkg_list, pkg_size)
return pkg_list, pkg_size
def list_lib(self, repo):
"""Return package lists
"""
packages = ""
if repo == "sbo":
if (os.path.isfile(
self.meta.lib_path + "{0}_repo/SLACKBUILDS.TXT".format(
repo))):
packages = Utils().read_file(self.meta.lib_path + "{0}_repo/"
"SLACKBUILDS.TXT".format(repo))
else:
if (os.path.isfile(
self.meta.lib_path + "{0}_repo/PACKAGES.TXT".format(repo))):
packages = Utils().read_file(self.meta.lib_path + "{0}_repo/"
"PACKAGES.TXT".format(repo))
return packages
def list_color_tag(self, pkg):
"""Tag with color installed packages
"""
name = GetFromInstalled(pkg).name()
find = name + self.meta.sp
if pkg.endswith(".txz") or pkg.endswith(".tgz"):
find = pkg[:-4]
if find_package(find, self.meta.pkg_path):
pkg = "{0}{1}{2}".format(self.meta.color["GREEN"], pkg,
self.meta.color["ENDC"])
return pkg
def list_of_installed(self, repo, name):
"""Return installed packages
"""
all_installed_names = []
all_installed_packages = find_package("", self.meta.pkg_path)
for inst in all_installed_packages:
if repo == "sbo" and inst.endswith("_SBo"):
name = split_package(inst)[0]
all_installed_names.append(name)
else:
if name:
all_installed_names.append(split_package(inst)[0])
else:
all_installed_names.append(inst)
return all_installed_names
class ArgParse(object):
def __init__(self, args):
self.args = args
self.meta = _meta_
self.msg = Msg()
self.commands = [
"update", "upgrade", "repo-add", "repo-remove", "repo-enable",
"repo-list", "repo-info", "update-slpkg", "health", "deps-status",
"new-config"
]
# checking if repositories exists
enabled_repos = _meta_.repositories
if len(self.args) > 1:
repo = check_exists_repositories(args[1])
if len(self.args) > 1 and self.args[0] in [
"-c", "--check", "-l", "--list", "-c", "--check", "-s",
"--sync", "-t", "--tracking", "-p", "--desc", "-F", "--FIND",
"-f", "--find"
] and self.args[1] == repo and repo in enabled_repos:
print("\n Please update packages lists. Run 'slpkg update'.\n" +
" This command should be used to synchronize packages\n" +
" lists from the repositories are enabled.\n")
raise SystemExit()
def help_version(self):
"""Help and version info
"""
if (len(self.args) == 1 and self.args[0] in ["-h", "--help"]
and self.args[1:] == []):
options()
elif (len(self.args) == 1 and self.args[0] in ["-v", "--version"]
and self.args[1:] == []):
prog_version()
else:
usage("")
def command_update(self):
"""Update package lists repositories
"""
if len(self.args) == 1 and self.args[0] == "update":
Update().repository(only="")
elif (len(self.args) == 2 and self.args[0] == "update"
and self.args[1].startswith("--only=")):
repos = self.args[1].split("=")[-1].split(",")
for rp in repos:
if rp not in self.meta.repositories:
repos.remove(rp)
Update().repository(repos)
else:
usage("")
def command_update_slpkg(self):
"""Slpkg it self update
"""
if len(self.args) == 2 and self.args[0] == "update-slpkg":
it_self_update()
else:
usage("")
def command_repo_enable(self):
"""Repositories enable/disable
"""
if len(self.args) == 1 and self.args[0] == "repo-enable":
RepoEnable().choose()
else:
usage("")
def command_repo_list(self):
"""Repositories list
"""
if len(self.args) == 1 and self.args[0] == "repo-list":
RepoList().repos()
else:
usage("")
def command_repo_add(self):
"""Add custom repositories
"""
if len(self.args) == 3 and self.args[0] == "repo-add":
Repo().add(self.args[1], self.args[2])
else:
usage("")
def command_repo_remove(self):
"""Remove custom repositories
"""
if len(self.args) == 2 and self.args[0] == "repo-remove":
Repo().remove(self.args[1])
else:
usage("")
def command_upgrade(self):
"""Recreate repositories package lists
"""
if len(self.args) == 1 and self.args[0] == "upgrade":
Initialization(False).upgrade(only="")
elif (len(self.args) == 2 and self.args[0] == "upgrade"
and self.args[1].startswith("--only=")):
repos = self.args[1].split("=")[-1].split(",")
for rp in repos:
if rp not in self.meta.repositories:
repos.remove(rp)
Initialization(False).upgrade(repos)
else:
usage("")
def command_repo_info(self):
"""Repositories informations
"""
if (len(self.args) == 2 and self.args[0] == "repo-info"
and self.args[1] in RepoList().all_repos):
del RepoList().all_repos
RepoInfo().view(self.args[1])
elif (len(self.args) > 1 and self.args[0] == "repo-info"
and self.args[1] not in RepoList().all_repos):
usage(self.args[1])
else:
usage("")
def command_health(self):
"""Check package health
"""
if len(self.args) == 1 and self.args[0] == "health":
PackageHealth(mode="").test()
elif (len(self.args) == 2 and self.args[0] == "health"
and self.args[1] == "--silent"):
PackageHealth(mode=self.args[1]).test()
else:
usage("")
def command_deps_status(self):
"""Print dependencies status
"""
image = ""
for arg in self.args:
if arg.startswith("--graph="):
image = arg.split("=")[1]
if len(self.args) == 1 and self.args[0] == "deps-status":
DependenciesStatus(image).show()
elif len(self.args) == 2 and self.args[0] == "deps-status" and image:
DependenciesStatus(image).show()
elif (len(self.args) == 2 and self.args[0] == "deps-status"
and "--tree" in self.args):
DependenciesStatus(image).tree()
elif (len(self.args) == 3 and self.args[0] == "deps-status"
and "--tree" in self.args and image):
DependenciesStatus(image).tree()
else:
usage("")
def command_new_config(self):
"""Manage .new configuration files
"""
if len(self.args) == 1 and self.args[0] == "new-config":
NewConfig().run()
else:
usage("")
def auto_build(self):
"""Auto built tool
"""
options = ["-a", "--autobuild"]
if len(self.args) >= 3 and self.args[0] in options:
AutoBuild(self.args[1], self.args[2:], self.meta.path).run()
else:
usage("")
def pkg_list(self):
"""List of packages by repository
"""
options = ["-l", "--list"]
flag = ["--index", "--installed", "--name"]
name = INDEX = installed = False
for arg in self.args[2:]:
if flag[0] == arg:
INDEX = True
if flag[1] in arg:
installed = True
if flag[2] == arg:
name = True
if arg not in flag:
usage("")
raise SystemExit()
if (len(self.args) > 1 and len(self.args) <= 5
and self.args[0] in options):
if self.args[1] in self.meta.repositories:
PackageManager(binary=None).package_list(
self.args[1], name, INDEX, installed)
else:
usage(self.args[1])
else:
usage("")
def pkg_upgrade(self):
"""Check and upgrade packages by repository
"""
options = ["-c", "--check"]
flags = [
"--upgrade", "--skip=", "--resolve-off", "--checklist", "--rebuild"
]
flag, skip = self.__pkg_upgrade_flags(flags)
if (len(self.args) == 3 and self.args[0] in options
and self.args[2] == flags[0]
and self.args[1] in self.meta.repositories):
if self.args[1] not in ["slack", "sbo"]:
BinaryInstall(pkg_upgrade(self.args[1], skip, flag),
self.args[1], flag).start(is_upgrade=True)
elif self.args[1] == "slack":
if self.meta.only_installed in ["on", "ON"]:
BinaryInstall(pkg_upgrade("slack", skip, flag), "slack",
flag).start(is_upgrade=True)
else:
Patches(skip, flag).start()
elif self.args[1] == "sbo":
SBoInstall(sbo_upgrade(skip, flag),
flag).start(is_upgrade=True)
else:
usage(self.args[1])
elif len(self.args) == 2 and self.args[0] in options:
if self.args[1] == "ALL":
Updates(repo="").ALL()
else:
Updates(self.args[1]).run()
elif (len(self.args) >= 2 and self.args[0] in options
and self.args[1] not in self.meta.repositories):
usage(self.args[1])
else:
usage("")
def __pkg_upgrade_flags(self, flags):
"""Manage flags for package upgrade option
"""
flag, skip = [], ""
if flags[0] in self.args:
for arg in self.args[3:]:
if arg.startswith(flags[1]):
skip = Regex(arg.split("=")[1]).get()
self.args.remove(arg)
if arg in flags:
flag.append(arg)
if arg in self.args:
self.args.remove(arg)
return flag, skip
def pkg_install(self):
"""Install packages by repository
"""
flag = []
options = ["-s", "--sync"]
additional_options = [
"--resolve-off", "--download-only", "--directory-prefix=",
"--case-ins", "--rebuild", "--reinstall"
]
for arg in self.args:
if arg.startswith(additional_options[2]):
flag.append(arg)
arg = ""
if arg in additional_options:
flag.append(arg)
if len(self.args) >= 3 and self.args[0] in options:
if (self.args[1] in self.meta.repositories
and self.args[1] not in ["sbo"]):
BinaryInstall(self.args[2:], self.args[1],
flag).start(is_upgrade=False)
elif (self.args[1] == "sbo"
and self.args[1] in self.meta.repositories):
SBoInstall(self.args[2:], flag).start(is_upgrade=False)
else:
usage(self.args[1])
else:
usage("")
def pkg_tracking(self):
"""Tracking package dependencies
"""
flag = []
options = ["-t", "--tracking"]
additional_options = ["--check-deps", "--graph=", "--case-ins"]
for arg in self.args[2:]:
if arg.startswith(additional_options[1]):
flag.append(arg)
self.args.remove(arg)
if arg in additional_options:
flag.append(arg)
# clean additional options from args
for f in flag:
if f in self.args:
self.args.remove(f)
# print usage message if wrong additional option
for arg in self.args:
if arg.startswith("--"):
if arg not in additional_options:
usage("")
raise SystemExit()
if (len(self.args) >= 3 and len(self.args) <= 3
and self.args[0] in options
and self.args[1] in self.meta.repositories):
TrackingDeps(self.args[2], self.args[1], flag).run()
elif (len(self.args) >= 2
and self.args[1] not in self.meta.repositories):
usage(self.args[1])
else:
usage("")
def sbo_network(self):
"""View slackbuilds packages
"""
flag = []
options = ["-n", "--network"]
additional_options = ["--checklist", "--case-ins"]
for add in additional_options:
if add in self.args:
flag.append(add)
self.args.remove(add)
if (len(self.args) == 2 and self.args[0] in options
and "sbo" in self.meta.repositories):
SBoNetwork(self.args[1], flag).view()
else:
usage("sbo")
def pkg_blacklist(self):
"""Manage blacklist packages
"""
blacklist = BlackList()
options = ["-b", "--blacklist"]
flag = ["--add", "--remove"]
command = ["list"]
if (len(self.args) == 2 and self.args[0] in options
and self.args[1] == command[0]):
blacklist.listed()
elif (len(self.args) > 2 and self.args[0] in options
and flag[0] in self.args):
self.args.remove(flag[0])
blacklist.add(self.args[1:])
elif (len(self.args) == 3 and self.args[0] in options
and "ALL" in self.args and flag[1] in self.args):
self.args.remove(flag[1])
blacklist.remove(blacklist.get_black())
elif (len(self.args) > 2 and self.args[0] in options
and flag[1] in self.args):
self.args.remove(flag[1])
blacklist.remove(self.args[1:])
else:
usage("")
def pkg_queue(self):
"""Manage packages in queue
"""
queue = QueuePkgs()
options = ["-q", "--queue"]
flag = ["--add", "--remove"]
command = ["list", "build", "install", "build-install"]
if (len(self.args) > 2 and self.args[0] in options
and flag[0] in self.args):
self.args.remove(flag[0])
queue.add(self.args[1:])
elif (len(self.args) == 3 and self.args[0] in options
and "ALL" in self.args and flag[1] in self.args):
self.args.remove(flag[1])
queue.remove(queue.packages())
elif (len(self.args) > 2 and self.args[0] in options
and flag[1] in self.args):
self.args.remove(flag[1])
queue.remove(self.args[1:])
elif (len(self.args) == 2 and self.args[0] in options
and self.args[1] == command[0]):
queue.listed()
elif (len(self.args) == 2 and self.args[0] in options
and self.args[1] == command[1]):
queue.build()
elif (len(self.args) == 2 and self.args[0] in options
and self.args[1] == command[2]):
queue.install()
elif (len(self.args) == 2 and self.args[0] in options
and self.args[1] == command[3]):
queue.build()
queue.install()
else:
usage("")
def bin_install(self):
"""Install Slackware binary packages
"""
packages = self.args[1:]
options = ["-i", "--installpkg"]
flag = ""
flags = [
"--warn", "--md5sum", "--root", "--infobox", "--menu", "--terse",
"--ask", "--priority", "--tagfile"
]
if len(self.args) > 1 and self.args[0] in options:
if self.args[1] in flags:
flag = self.args[1]
packages = self.args[2:]
PackageManager(packages).install(flag)
else:
usage("")
def bin_upgrade(self):
"""Install-upgrade Slackware binary packages
"""
packages = self.args[1:]
options = ["-u", "--upgradepkg"]
flag = ""
flags = ["--dry-run", "--install-new", "--reinstall", "--verbose"]
if len(self.args) > 1 and self.args[0] in options:
if self.args[1] in flags:
flag = self.args[1]
packages = self.args[2:]
PackageManager(packages).upgrade(flag)
else:
usage("")
def bin_remove(self):
"""Remove Slackware packages
"""
packages = self.args[1:]
options = ["-r", "--removepkg"]
additional_options = ["--deps", "--check-deps", "--tag", "--checklist"]
flag, extra = "", []
flags = ["-warn", "-preserve", "-copy", "-keep"]
# merge --check-deps and --deps options
if (additional_options[1] in self.args
and additional_options[0] not in self.args):
self.args.append(additional_options[0])
if len(self.args) > 1 and self.args[0] in options:
for additional in additional_options:
if additional in self.args:
extra.append(additional)
self.args.remove(additional)
packages = self.args[1:]
for fl in flags:
if fl in self.args:
flag = self.args[1]
packages = self.args[2:]
PackageManager(packages).remove(flag, extra)
else:
usage("")
def bin_find(self):
"""Find installed packages
"""
flag = []
options = ["-f", "--find"]
additional_options = ["--case-ins"]
for arg in self.args:
if arg in additional_options:
flag.append(arg)
self.args.remove(arg)
packages = self.args[1:]
if len(self.args) > 1 and self.args[0] in options:
PackageManager(packages).find(flag)
else:
usage("")
def pkg_desc(self):
"""Print slack-desc by repository
"""
options = ["-p", "--desc"]
flag = ["--color="]
colors = ["red", "green", "yellow", "cyan", "grey"]
tag = ""
for arg in self.args:
if arg.startswith(flag[0]):
tag = arg[len(flag[0]):]
self.args.remove(arg)
break
if tag and tag not in colors:
print("\nslpkg: Error: Available colors {0}\n".format(colors))
raise SystemExit()
if (len(self.args) == 3 and self.args[0] in options
and self.args[1] in self.meta.repositories and tag in colors):
PkgDesc(self.args[2], self.args[1], tag).view()
elif (len(self.args) == 3 and self.args[0] in options
and self.args[1] in self.meta.repositories):
PkgDesc(self.args[2], self.args[1], paint="").view()
elif (len(self.args) > 1 and self.args[0] in options
and self.args[1] not in self.meta.repositories):
usage(self.args[1])
else:
usage("")
def pkg_find(self):
"""Find packages from all enabled repositories
"""
flag = []
options = ["-F", "--FIND"]
additional_options = ["--case-ins"]
for arg in self.args:
if arg in additional_options:
flag.append(arg)
self.args.remove(arg)
packages = self.args[1:]
if len(self.args) > 1 and self.args[0] in options:
FindFromRepos().find(packages, flag)
else:
usage("")
def pkg_contents(self):
"""Print packages contents
"""
packages = self.args[1:]
options = ["-d", "--display"]
if len(self.args) > 1 and self.args[0] in options:
PackageManager(packages).display()
else:
usage("")
def congiguration(self):
"""Manage slpkg configuration file
"""
options = ["-g", "--config"]
command = ["print", "edit", "reset"]
conf = Config()
if (len(self.args) == 2 and self.args[0] in options
and self.args[1] == command[1]):
conf.edit()
elif (len(self.args) == 2 and self.args[0] in options
and self.args[1] == (command[0])):
conf.view()
elif (len(self.args) == 2 and self.args[0] in options
and self.args[1] == (command[2])):
conf.reset()
else:
usage("")
def auto_detect(self, args):
"""Check for already Slackware binary packages exist
"""
suffixes = [".tgz", ".txz", ".tbz", ".tlz"]
if (not args[0].startswith("-") and args[0] not in self.commands
and args[0].endswith(tuple(suffixes))):
packages, not_found = [], []
for pkg in args:
if pkg.endswith(tuple(suffixes)):
if os.path.isfile(pkg):
packages.append(pkg)
else:
not_found.append(pkg)
if packages:
Auto(packages).select()
if not_found:
for ntf in not_found:
self.msg.pkg_not_found("", ntf, "Not installed", "")
raise SystemExit()
class ArgParse(object):
def __init__(self, args):
self.args = args
self.meta = _meta_
self.msg = Msg()
self.commands = [
"update",
"upgrade",
"repo-add",
"repo-remove",
"repo-enable",
"repo-list",
"repo-info",
"update-slpkg",
"health",
"deps-status",
"new-config"
]
# checking if repositories exists
if len(self.args) > 1 and self.args[0] not in [
"-h", "--help", "-v", "--version", "upgrade", "repo-enable",
"repo-list", "repo-add", "repo-remove", "update", "update-slpkg",
"health", "-g", "--config"
]:
check_exists_repositories()
def help_version(self):
"""Help and version info
"""
if (len(self.args) == 1 and self.args[0] in ["-h", "--help"] and
self.args[1:] == []):
options()
elif (len(self.args) == 1 and self.args[0] in ["-v", "--version"] and
self.args[1:] == []):
prog_version()
else:
usage("")
def command_update(self):
"""Update package lists repositories
"""
if len(self.args) == 1 and self.args[0] == "update":
Update().repository(only="")
elif (len(self.args) == 2 and self.args[0] == "update" and
self.args[1].startswith("--only=")):
repos = self.args[1].split("=")[-1].split(",")
for rp in repos:
if rp not in self.meta.repositories:
repos.remove(rp)
Update().repository(repos)
else:
usage("")
def command_update_slpkg(self):
"""Slpkg it self update
"""
if len(self.args) == 2 and self.args[0] == "update-slpkg":
it_self_update()
else:
usage("")
def command_repo_enable(self):
"""Repositories enable/disable
"""
if len(self.args) == 1 and self.args[0] == "repo-enable":
RepoEnable().choose()
else:
usage("")
def command_repo_list(self):
"""Repositories list
"""
if len(self.args) == 1 and self.args[0] == "repo-list":
RepoList().repos()
else:
usage("")
def command_repo_add(self):
"""Add custom repositories
"""
if len(self.args) == 3 and self.args[0] == "repo-add":
Repo().add(self.args[1], self.args[2])
else:
usage("")
def command_repo_remove(self):
"""Remove custom repositories
"""
if len(self.args) == 2 and self.args[0] == "repo-remove":
Repo().remove(self.args[1])
else:
usage("")
def command_upgrade(self):
"""Recreate repositories package lists
"""
if len(self.args) == 1 and self.args[0] == "upgrade":
Initialization(False).upgrade(only="")
elif (len(self.args) == 2 and self.args[0] == "upgrade" and
self.args[1].startswith("--only=")):
repos = self.args[1].split("=")[-1].split(",")
Initialization(False).upgrade(repos)
else:
usage("")
def command_repo_info(self):
"""Repositories informations
"""
if (len(self.args) == 2 and self.args[0] == "repo-info" and
self.args[1] in RepoList().all_repos):
del RepoList().all_repos
RepoInfo().view(self.args[1])
elif (len(self.args) > 1 and self.args[0] == "repo-info" and
self.args[1] not in RepoList().all_repos):
usage(self.args[1])
else:
usage("")
def command_health(self):
"""Check package health
"""
if len(self.args) == 1 and self.args[0] == "health":
PackageHealth(mode="").test()
elif (len(self.args) == 2 and self.args[0] == "health" and
self.args[1] == "--silent"):
PackageHealth(mode=self.args[1]).test()
else:
usage("")
def command_deps_status(self):
"""Print dependencies status
"""
if len(self.args) == 1 and self.args[0] == "deps-status":
DependenciesStatus(image="").show()
elif (len(self.args) == 2 and self.args[0] == "deps-status" and
self.args[1].startswith("--graph=")):
image = self.args[1].split("=")[1]
DependenciesStatus(image).show()
elif (len(self.args) == 2 and self.args[0] == "deps-status" and
self.args[1] == "--tree"):
DependenciesStatus(image="").tree()
else:
usage("")
def command_new_config(self):
"""Manage .new configuration files
"""
if len(self.args) == 1 and self.args[0] == "new-config":
NewConfig().run()
else:
usage("")
def auto_build(self):
"""Auto built tool
"""
options = [
"-a",
"--autobuild"
]
if len(self.args) >= 3 and self.args[0] in options:
AutoBuild(self.args[1], self.args[2:], self.meta.path).run()
else:
usage("")
def pkg_list(self):
"""List of packages by repository
"""
options = [
"-l",
"--list"
]
flag = ["--index", "--installed"]
if (len(self.args) == 3 and self.args[0] in options and
self.args[1] in self.meta.repositories):
if self.args[2] == flag[0]:
PackageManager(binary=None).package_list(self.args[1],
INDEX=True,
installed=False)
elif self.args[2] == flag[1]:
PackageManager(binary=None).package_list(self.args[1],
INDEX=False,
installed=True)
else:
usage("")
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] in self.meta.repositories):
PackageManager(None).package_list(self.args[1], INDEX=False,
installed=False)
elif (len(self.args) > 1 and self.args[0] in options and
self.args[1] not in self.meta.repositories):
usage(self.args[1])
else:
usage("")
def pkg_upgrade(self):
"""Check and upgrade packages by repository
"""
options = [
"-c",
"--check"
]
flags = [
"--upgrade",
"--skip=",
"--resolve-off",
"--checklist"
]
flag, skip = self.__pkg_upgrade_flags(flags)
if (len(self.args) == 3 and self.args[0] in options and
self.args[2] == flags[0] and
self.args[1] in self.meta.repositories):
if self.args[1] not in ["slack", "sbo"]:
BinaryInstall(pkg_upgrade(self.args[1], skip, flag),
self.args[1], flag).start(if_upgrade=True)
elif self.args[1] == "slack":
if self.meta.only_installed in ["on", "ON"]:
BinaryInstall(pkg_upgrade("slack", skip, flag),
"slack", flag).start(if_upgrade=True)
else:
Patches(skip, flag).start()
elif self.args[1] == "sbo":
SBoInstall(sbo_upgrade(skip, flag), flag).start(if_upgrade=True)
else:
usage(self.args[1])
elif len(self.args) == 2 and self.args[0] in options:
if self.args[1] == "ALL":
Updates(repo="").ALL()
else:
Updates(self.args[1]).run()
elif (len(self.args) >= 2 and self.args[0] in options and
self.args[1] not in self.meta.repositories):
usage(self.args[1])
else:
usage("")
def __pkg_upgrade_flags(self, flags):
"""Manage flags for package upgrade option
"""
flag, skip = [], ""
if flags[0] in self.args:
for arg in self.args[3:]:
if arg.startswith(flags[1]):
skip = Regex(arg.split("=")[1]).get()
self.args.remove(arg)
if arg in flags:
flag.append(arg)
self.args.remove(arg)
return flag, skip
def pkg_install(self):
"""Install packages by repository
"""
flag = []
options = [
"-s",
"--sync"
]
additional_options = [
"--resolve-off",
"--case-ins"
]
for arg in self.args:
if arg in additional_options:
flag.append(arg)
if len(self.args) >= 3 and self.args[0] in options:
if (self.args[1] in self.meta.repositories and
self.args[1] not in ["sbo"]):
BinaryInstall(self.args[2:], self.args[1], flag).start(
if_upgrade=False)
elif (self.args[1] == "sbo" and
self.args[1] in self.meta.repositories):
SBoInstall(self.args[2:], flag).start(if_upgrade=False)
else:
usage(self.args[1])
else:
usage("")
def pkg_tracking(self):
"""Tracking package dependencies
"""
flag = []
options = [
"-t",
"--tracking"
]
additional_options = [
"--check-deps",
"--graph="
]
if (len(self.args) >= 3 and len(self.args) < 6 and
self.args[0] in options):
if self.args[1] in self.meta.repositories:
for arg in self.args[3:]:
if arg.startswith(additional_options[1]):
flag.append(arg)
if arg in additional_options:
flag.append(arg)
TrackingDeps(self.args[2], self.args[1], flag).run()
else:
usage(self.args[1])
else:
usage("")
def sbo_network(self):
"""View slackbuilds packages
"""
flag = []
options = [
"-n",
"--network"
]
additional_options = [
"--checklist",
"--case-ins"
]
for arg in self.args[2:]:
if arg in additional_options:
flag.append(arg)
self.args.remove(arg)
if (len(self.args) == 2 and self.args[0] in options and
"sbo" in self.meta.repositories):
SBoNetwork(self.args[1], flag).view()
else:
usage("sbo")
def pkg_blacklist(self):
"""Manage blacklist packages
"""
blacklist = BlackList()
options = [
"-b",
"--blacklist"
]
flag = [
"--add",
"--remove"
]
command = ["list"]
if (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[0]):
blacklist.listed()
elif (len(self.args) > 2 and self.args[0] in options and
self.args[-1] == flag[0]):
blacklist.add(self.args[1:-1])
elif (len(self.args) == 3 and self.args[0] in options and
self.args[1] == "ALL" and self.args[-1] == flag[1]):
blacklist.remove(blacklist.get_black())
elif (len(self.args) > 2 and self.args[0] in options and
self.args[-1] == flag[1]):
blacklist.remove(self.args[1:-1])
else:
usage("")
def pkg_queue(self):
"""Manage packages in queue
"""
queue = QueuePkgs()
options = [
"-q",
"--queue"
]
flag = [
"--add",
"--remove"
]
command = [
"list",
"build",
"install",
"build-install"
]
if (len(self.args) > 2 and self.args[0] in options and
self.args[-1] == flag[0]):
queue.add(self.args[1:-1])
elif (len(self.args) == 3 and self.args[0] in options and
self.args[1] == "ALL" and self.args[-1] == flag[1]):
queue.remove(queue.packages())
elif (len(self.args) > 2 and self.args[0] in options and
self.args[-1] == flag[1]):
queue.remove(self.args[1:-1])
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[0]):
queue.listed()
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[1]):
queue.build()
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[2]):
queue.install()
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[3]):
queue.build()
queue.install()
else:
usage("")
def bin_install(self):
"""Install Slackware binary packages
"""
packages = self.args[1:]
options = [
"-i",
"--installpkg"
]
flag = ""
flags = [
"--warn",
"--md5sum",
"--root",
"--infobox",
"--menu",
"--terse",
"--ask",
"--priority",
"--tagfile"
]
if len(self.args) > 1 and self.args[0] in options:
if self.args[1] in flags:
flag = self.args[1]
packages = self.args[2:]
PackageManager(packages).install(flag)
else:
usage("")
def bin_upgrade(self):
"""Install-upgrade Slackware binary packages
"""
packages = self.args[1:]
options = [
"-u",
"--upgradepkg"
]
flag = ""
flags = [
"--dry-run",
"--install-new",
"--reinstall",
"--verbose"
]
if len(self.args) > 1 and self.args[0] in options:
if self.args[1] in flags:
flag = self.args[1]
packages = self.args[2:]
PackageManager(packages).upgrade(flag)
else:
usage("")
def bin_remove(self):
"""Remove Slackware packages
"""
packages = self.args[1:]
options = [
"-r",
"--removepkg"
]
additional_options = [
"--deps",
"--check-deps",
"--tag",
"--checklist"
]
flag, extra = "", []
flags = [
"-warn",
"-preserve",
"-copy",
"-keep"
]
if len(self.args) > 1 and self.args[0] in options:
for additional in additional_options:
if additional in self.args:
extra.append(additional)
self.args.remove(additional)
packages = self.args[1:]
if self.args[1] in flags:
flag = self.args[1]
packages = self.args[2:]
PackageManager(packages).remove(flag, extra)
else:
usage("")
def bin_find(self):
"""Find installed packages
"""
flag = []
options = [
"-f",
"--find"
]
additional_options = ["--case-ins"]
for arg in self.args:
if arg in additional_options:
flag.append(arg)
self.args.remove(arg)
packages = self.args[1:]
if len(self.args) > 1 and self.args[0] in options:
PackageManager(packages).find(flag)
else:
usage("")
def pkg_desc(self):
"""Print slack-desc by repository
"""
options = [
"-p",
"--desc"
]
flag = ["--color="]
colors = [
"red",
"green",
"yellow",
"cyan",
"grey"
]
if (len(self.args) == 3 and self.args[0] in options and
self.args[1] in self.meta.repositories):
PkgDesc(self.args[2], self.args[1], paint="").view()
elif (len(self.args) == 4 and self.args[0] in options and
self.args[3].startswith(flag[0])):
tag = self.args[3][len(flag[0]):]
if self.args[1] in self.meta.repositories and tag in colors:
PkgDesc(self.args[2], self.args[1], tag).view()
else:
usage(self.args[1])
elif (len(self.args) > 1 and self.args[0] in options and
self.args[1] not in self.meta.repositories):
usage(self.args[1])
else:
usage("")
def pkg_find(self):
"""Find packages from all enabled repositories
"""
flag = []
options = [
"-F",
"--FIND"
]
additional_options = ["--case-ins"]
for arg in self.args:
if arg in additional_options:
flag.append(arg)
self.args.remove(arg)
packages = self.args[1:]
if len(self.args) > 1 and self.args[0] in options:
find_from_repos(packages, flag)
else:
usage("")
def pkg_contents(self):
"""Print packages contents
"""
packages = self.args[1:]
options = [
"-d",
"--display"
]
if len(self.args) > 1 and self.args[0] in options:
PackageManager(packages).display()
else:
usage("")
def congiguration(self):
"""Manage slpkg configuration file
"""
options = [
"-g",
"--config"
]
command = [
"print",
"edit",
"reset"
]
if (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[1]):
Config().edit()
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == (command[0])):
Config().view()
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == (command[2])):
Config().reset()
else:
usage("")
def auto_detect(self, args):
"""Check for already Slackware binary packages exist
"""
suffixes = [
".tgz",
".txz",
".tbz",
".tlz"
]
if (not args[0].startswith("-") and args[0] not in self.commands and
args[0].endswith(tuple(suffixes))):
packages, not_found = [], []
for pkg in args:
if pkg.endswith(tuple(suffixes)):
if os.path.isfile(pkg):
packages.append(pkg)
else:
not_found.append(pkg)
if packages:
Auto(packages).select()
if not_found:
for ntf in not_found:
self.msg.pkg_not_found("", ntf, "Not installed", "")
raise SystemExit()
class BuildPackage(object):
"""Build SBo packages from source
"""
def __init__(self, script, sources, path, auto):
self.script = script
self.sources = sources
self.path = path
self.auto = auto
self.meta = _meta_
self.msg = Msg()
self._SOURCES = self.meta._SBo_SOURCES
self.prgnam = self.script[:-7]
self.log_file = "build_{0}_log".format(self.prgnam)
self.sbo_logs = self.meta.log_path + "sbo/"
self.build_logs = self.sbo_logs + "build_logs/"
self.start_log_time = time.strftime("%H:%M:%S")
self.start_time = time.time()
if not os.path.exists(self.meta.log_path):
os.mkdir(self.meta.log_path)
if not os.path.exists(self.sbo_logs):
os.mkdir(self.sbo_logs)
if not os.path.exists(self.build_logs):
os.mkdir(self.build_logs)
def build(self):
"""
Build package from source and create log
file in path /var/log/slpkg/sbo/build_logs/.
Also check md5sum calculates.
"""
try:
self._delete_dir()
tar = tarfile.open(self.script)
tar.extractall()
tar.close()
self._makeflags()
self._delete_sbo_tar_gz()
self._create_md5_dict()
if not self.auto:
os.chdir(self._SOURCES)
for src in self.sources:
# fix build sources with spaces
src = src.replace("%20", " ")
check_md5(self.sbo_md5[src], src)
shutil.copy2(src, self.path + self.prgnam)
os.chdir(self.path + self.prgnam)
# change permissions
subprocess.call("chmod +x {0}.SlackBuild".format(self.prgnam),
shell=True)
pass_var = self._pass_variable()
if self.meta.sbo_build_log in ["on", "ON"]:
if os.path.isfile(self.build_logs + self.log_file):
os.remove(self.build_logs + self.log_file)
# start log write
log_head(self.build_logs, self.log_file, self.start_log_time)
subprocess.Popen("{0} ./{1}.SlackBuild 2>&1 | tee -a "
"{2}{3}".format(" ".join(pass_var),
self.prgnam, self.build_logs,
self.log_file), shell=True,
stdout=sys.stdout).communicate()
sum_time = build_time(self.start_time)
# write end in log file
log_end(self.build_logs, self.log_file, sum_time)
print("Total build time for package {0} : {1}\n".format(
self.prgnam, sum_time))
else:
subprocess.call("{0} ./{1}.SlackBuild".format(
" ".join(pass_var), self.prgnam), shell=True)
os.chdir(self.path)
except KeyboardInterrupt: # (OSError, IOError):
self.msg.pkg_not_found("\n", self.prgnam, "Wrong file", "\n")
def _create_md5_dict(self):
"""Create md5 dictionary per source
"""
self.sbo_md5 = {}
md5_lists = SBoGrep(self.prgnam).checksum()
for src, md5 in zip(self.sources, md5_lists):
self.sbo_md5[src] = md5
def _makeflags(self):
"""Set variable MAKEFLAGS with the numbers of
processors
"""
if self.meta.makeflags in ["on", "ON"]:
cpus = multiprocessing.cpu_count()
os.environ["MAKEFLAGS"] = "-j{0}".format(cpus)
def _pass_variable(self):
"""Return enviroment variables
"""
pass_var = []
for var in os.environ.keys():
expVAR = var.split("_")
if expVAR[0] == self.prgnam.upper() and expVAR[1] != "PATH":
pass_var.append("{0}={1}".format(expVAR[1], os.environ[var]))
return pass_var
def _delete_sbo_tar_gz(self):
"""Delete slackbuild tar.gz file after untar
"""
if not self.auto and os.path.isfile(self.meta.build_path + self.script):
os.remove(self.meta.build_path + self.script)
def _delete_dir(self):
"""Delete old folder if exists before start build
"""
if not self.auto and os.path.isdir(self.meta.build_path + self.prgnam):
shutil.rmtree(self.meta.build_path + self.prgnam)
class SBoNetwork(object):
"""View SBo site in terminal and also read, build or
install packages
"""
def __init__(self, name, flag):
self.name = name
self.flag = flag
self.meta = _meta_
self.msg = Msg()
self.arch = SBoArch().get()
self.comp_tar = ".tar.gz"
self.choice = ""
self.FAULT = ""
self.green = self.meta.color["GREEN"]
self.red = self.meta.color["RED"]
self.yellow = self.meta.color["YELLOW"]
self.cyan = self.meta.color["CYAN"]
self.grey = self.meta.color["GREY"]
self.endc = self.meta.color["ENDC"]
self.build_folder = self.meta.build_path
self._SOURCES = self.meta.SBo_SOURCES
self.msg.reading()
self.data = SBoGrep(name="").names()
self.case_insensitive()
if "--checklist" in self.flag:
self.with_checklist()
grep = SBoGrep(self.name)
self.sbo_files = grep.files()
self.blacklist = BlackList().packages(pkgs=self.data, repo="sbo")
self.sbo_url = sbo_search_pkg(self.name)
if self.sbo_url:
self.sbo_desc = grep.description()[len(self.name) + 2:-1]
self.source_dwn = grep.source().split()
self.sbo_req = grep.requires()
self.sbo_dwn = SBoLink(self.sbo_url).tar_gz()
self.sbo_version = grep.version()
self.dwn_srcs = self.sbo_dwn.split() + self.source_dwn
if "--checklist" not in self.flag or not self.sbo_url and self.name:
self.msg.done()
def view(self):
"""View SlackBuild package, read or install them
from slackbuilds.org
"""
if self.sbo_url and self.name not in self.blacklist:
self.prgnam = ("{0}-{1}".format(self.name, self.sbo_version))
self.view_sbo()
while True:
self.read_choice()
choice = {
"r": self.choice_README,
"R": self.choice_README,
"s": self.choice_SlackBuild,
"S": self.choice_SlackBuild,
"f": self.choice_info,
"F": self.choice_info,
"o": self.choice_doinst,
"O": self.choice_doinst,
"d": self.choice_download,
"D": self.choice_download,
"download": self.choice_download,
"b": self.choice_build,
"B": self.choice_build,
"build": self.choice_build,
"i": self.choice_install,
"I": self.choice_install,
"install": self.choice_install,
"c": self.choice_clear_screen,
"C": self.choice_clear_screen,
"clear": self.choice_clear_screen,
"q": self.choice_quit,
"quit": self.choice_quit,
"Q": self.choice_quit
}
try:
choice[self.choice]()
except KeyError:
pass
else:
self.msg.pkg_not_found("\n", self.name, "Can't view", "\n")
raise SystemExit(1)
def case_insensitive(self):
"""Matching packages distinguish between uppercase and
lowercase
"""
if "--case-ins" in self.flag:
data_dict = Utils().case_sensitive(self.data)
for key, value in data_dict.iteritems():
if key == self.name.lower():
self.name = value
def read_choice(self):
"""Return choice
"""
commands = {
"r": "README",
"R": "README",
"s": "{0}.SlackBuild".format(self.name),
"S": "{0}.SlackBuild".format(self.name),
"f": "{0}.info".format(self.name),
"F": "{0}.info".format(self.name),
"o": "doinst.sh",
"O": "doinst.sh",
"d": "download",
"D": "download",
"download": "download",
"b": "build",
"B": "build",
"build": "build",
"i": "install",
"I": "install",
"install": "install",
"c": "clear",
"C": "clear",
"clear": "clear",
"q": "quit",
"quit": "quit",
"Q": "quit"
}
try:
message = " Choose an option > "
self.choice = raw_input("{0}{1}{2}".format(self.grey, message,
self.endc))
except EOFError:
print("")
raise SystemExit()
try:
sys.stdout.write("{0}\x1b[1A{1}{2}{3}\n".format(
" " * len(message), self.cyan, commands[self.choice],
self.endc))
sys.stdout.flush()
except KeyError:
pass
def choice_README(self):
"""View README file
"""
README = ReadSBo(self.sbo_url).readme("README")
fill = self.fill_pager(README)
self.pager(README + fill)
def choice_SlackBuild(self):
"""View .SlackBuild file
"""
SlackBuild = ReadSBo(self.sbo_url).slackbuild(self.name, ".SlackBuild")
fill = self.fill_pager(SlackBuild)
self.pager(SlackBuild + fill)
def choice_info(self):
"""View .info file
"""
info = ReadSBo(self.sbo_url).info(self.name, ".info")
fill = self.fill_pager(info)
self.pager(info + fill)
def choice_doinst(self):
"""View doinst.sh file
"""
if "doinst.sh" in self.sbo_files.split():
doinst_sh = ReadSBo(self.sbo_url).doinst("doinst.sh")
fill = self.fill_pager(doinst_sh)
self.pager(doinst_sh + fill)
def choice_download(self):
"""Download script.tar.gz and sources
"""
Download(path="", url=self.dwn_srcs, repo="sbo").start()
raise SystemExit()
def choice_build(self):
"""Build package
"""
self.build()
delete(self.build_folder)
raise SystemExit()
def choice_install(self):
"""Download, build and install package
"""
pkg_security([self.name])
if not find_package(self.prgnam, self.meta.pkg_path):
self.build()
self.install()
delete(self.build_folder)
raise SystemExit()
else:
self.msg.template(78)
self.msg.pkg_found(self.prgnam)
self.msg.template(78)
raise SystemExit()
def choice_clear_screen(self):
"""Clear screen
"""
os.system("clear")
self.view()
def choice_quit(self):
"""Quit from choices
"""
raise SystemExit()
def view_sbo(self):
"""View slackbuild.org
"""
sbo_url = self.sbo_url.replace("/slackbuilds/", "/repository/")
br1, br2, fix_sp = "", "", " "
if self.meta.use_colors in ["off", "OFF"]:
br1 = "("
br2 = ")"
fix_sp = ""
print("") # new line at start
self.msg.template(78)
print("| {0}{1}SlackBuilds Repository{2}".format(
" " * 28, self.grey, self.endc))
self.msg.template(78)
print("| {0} > {1} > {2}{3}{4}".format(slack_ver(),
sbo_url.split("/")[-3].title(),
self.cyan, self.name,
self.endc))
self.msg.template(78)
print("| {0}Package url{1}: {2}".format(self.green, self.endc,
sbo_url))
self.msg.template(78)
print("| {0}Description: {1}{2}".format(self.green, self.endc,
self.sbo_desc))
print("| {0}SlackBuild: {1}{2}".format(self.green, self.endc,
self.sbo_dwn.split("/")[-1]))
print("| {0}Sources: {1}{2}".format(
self.green, self.endc,
(", ".join([src.split("/")[-1] for src in self.source_dwn]))))
print("| {0}Requirements: {1}{2}".format(self.yellow, self.endc,
", ".join(self.sbo_req)))
self.msg.template(78)
print("| {0}R{1}{2}EADME View the README file".format(
self.red, self.endc, br2))
print("| {0}S{1}{2}lackBuild View the .SlackBuild "
"file".format(self.red, self.endc, br2))
print("| In{0}{1}f{2}{3}o{4} View the .info "
"file".format(br1, self.red, self.endc, br2, fix_sp))
if "doinst.sh" in self.sbo_files.split():
print("| D{0}{1}o{2}{3}inst.sh{4} View the doinst.sh "
"file".format(br1, self.red, self.endc, br2, fix_sp))
print("| {0}D{1}{2}ownload Download this package".format(
self.red, self.endc, br2))
print("| {0}B{1}{2}uild Download and build".format(
self.red, self.endc, br2))
print("| {0}I{1}{2}nstall Download/Build/Install".format(
self.red, self.endc, br2))
print("| {0}C{1}{2}lear Clear screen".format(
self.red, self.endc, br2))
print("| {0}Q{1}{2}uit Quit".format(
self.red, self.endc, br2))
self.msg.template(78)
def with_checklist(self):
"""Using dialog and checklist option
"""
data = []
if self.name == "ALL":
data = self.data
else:
for name in self.data:
if self.name in name:
data.append(name)
if data:
text = "Press 'spacebar' to choose SlackBuild for view"
title = " SlackBuilds.org "
backtitle = "{0} {1}".format(_meta_.__all__, _meta_.__version__)
status = False
pkg = DialogUtil(data, text, title, backtitle, status).checklist()
if pkg and len(pkg) > 1:
print("\nslpkg: Error: Choose only one package")
raise SystemExit()
if pkg is None:
raise SystemExit()
self.name = "".join(pkg)
os.system("clear")
def pager(self, text):
"""Read text
"""
pydoc.pager(text)
def fill_pager(self, page):
"""Fix pager spaces
"""
tty_size = os.popen("stty size", "r").read().split()
rows = int(tty_size[0]) - 1
lines = sum(1 for line in page.splitlines())
diff = rows - lines
fill = "\n" * diff
if diff > 0:
return fill
else:
return ""
def error_uns(self):
"""Check if package supported by arch
before proceed to install
"""
self.FAULT = ""
UNST = ["UNSUPPORTED", "UNTESTED"]
if "".join(self.source_dwn) in UNST:
self.FAULT = "".join(self.source_dwn)
def build(self):
"""Only build and create Slackware package
"""
pkg_security([self.name])
self.error_uns()
if self.FAULT:
print("")
self.msg.template(78)
print("| Package {0} {1} {2} {3}".format(self.prgnam, self.red,
self.FAULT, self.endc))
self.msg.template(78)
else:
sources = []
if not os.path.exists(self.meta.build_path):
os.makedirs(self.meta.build_path)
if not os.path.exists(self._SOURCES):
os.makedirs(self._SOURCES)
os.chdir(self.meta.build_path)
Download(self.meta.build_path, self.sbo_dwn.split(),
repo="sbo").start()
Download(self._SOURCES, self.source_dwn, repo="sbo").start()
script = self.sbo_dwn.split("/")[-1]
for src in self.source_dwn:
sources.append(src.split("/")[-1])
BuildPackage(script, sources, self.meta.build_path,
auto=False).build()
slack_package(self.prgnam) # check if build
def install(self):
"""Install SBo package found in /tmp directory.
"""
binary = slack_package(self.prgnam)
print("[ {0}Installing{1} ] --> {2}".format(self.green, self.endc,
self.name))
PackageManager(binary).upgrade(flag="--install-new")
