class RepoList(object):
"""List of repositories
"""
def __init__(self):
self.meta = _meta_
self.msg = Msg()
self.all_repos = Repo().default_repository()
self.all_repos["slack"] = Repo().slack()
self.all_repos.update(Repo().custom_repository())
def repos(self):
"""View or enabled or disabled repositories
"""
def_cnt, cus_cnt = 0, 0
print("")
self.msg.template(78)
print("{0}{1}{2}{3}{4}{5}{6}".format(
"| Repo id", " " * 2,
"Repo URL", " " * 44,
"Default", " " * 3,
"Status"))
self.msg.template(78)
for repo_id, repo_URL in sorted(self.all_repos.iteritems()):
status, COLOR = "disabled", self.meta.color["RED"]
default = "yes"
if len(repo_URL) > 49:
repo_URL = repo_URL[:48] + "~"
if repo_id in self.meta.repositories:
def_cnt += 1
status, COLOR = "enabled", self.meta.color["GREEN"]
if repo_id not in self.meta.default_repositories:
cus_cnt += 1
default = "no"
print(" {0}{1}{2}{3}{4}{5}{6}{7:>8}{8}".format(
repo_id, " " * (9 - len(repo_id)),
repo_URL, " " * (52 - len(repo_URL)),
default, " " * (8 - len(default)),
COLOR, status, self.meta.color["ENDC"]))
print("\nRepositories summary")
print("=" * 79)
print("{0}{1}/{2} enabled default repositories and {3} custom.".format(
self.meta.color["GREY"], def_cnt, len(self.all_repos), cus_cnt))
print("For enable or disable default repositories edit "
"'/etc/slpkg/repositories.conf'\nfile.\n{0}".format(
self.meta.color["ENDC"]))
raise SystemExit()
class RepoList(object):
"""List of repositories
"""
def __init__(self):
self.meta = _meta_
self.msg = Msg()
self.all_repos = Repo().default_repository()
self.all_repos["slack"] = Repo().slack()
self.all_repos.update(Repo().custom_repository())
def repos(self):
"""View or enabled or disabled repositories
"""
def_cnt, cus_cnt = 0, 0
print("")
self.msg.template(78)
print("{0}{1}{2}{3}{4}{5}{6}".format("| Repo id", " " * 2, "Repo URL",
" " * 44, "Default", " " * 3,
"Status"))
self.msg.template(78)
for repo_id, repo_URL in sorted(self.all_repos.iteritems()):
status, COLOR = "disabled", self.meta.color["RED"]
default = "yes"
if len(repo_URL) > 49:
repo_URL = repo_URL[:48] + "~"
if repo_id in self.meta.repositories:
def_cnt += 1
status, COLOR = "enabled", self.meta.color["GREEN"]
if repo_id not in self.meta.default_repositories:
cus_cnt += 1
default = "no"
print(" {0}{1}{2}{3}{4}{5}{6}{7:>8}{8}".format(
repo_id, " " * (9 - len(repo_id)), repo_URL,
" " * (52 - len(repo_URL)), default, " " * (8 - len(default)),
COLOR, status, self.meta.color["ENDC"]))
print("\nRepositories summary")
print("=" * 79)
print("{0}{1}/{2} enabled default repositories and {3} custom.".format(
self.meta.color["GREY"], def_cnt, len(self.all_repos), cus_cnt))
print("For enable or disable default repositories edit "
"'/etc/slpkg/repositories.conf'\nfile or run 'slpkg "
"repo-enable' command.\n{0}".format(self.meta.color["ENDC"]))
raise SystemExit()
class Auto(object):
"""Select Slackware command to install packages
"""
def __init__(self, packages):
self.packages = packages
self.meta = _meta_
self.msg = Msg()
self.commands = {
"i": "installpkg",
"u": "upgradepkg --install-new",
"r": "upgradepkg --reinstall"
}
def select(self):
"""Select Slackware command
"""
print("\nDetected Slackware binary package for installation:\n")
for pkg in self.packages:
print(" " + pkg.split("/")[-1])
print("")
self.msg.template(78)
print("| Choose a Slackware command:")
self.msg.template(78)
for com in sorted(self.commands):
print("| {0}{1}{2}) {3}{4}{5}".format(self.meta.color["RED"], com,
self.meta.color["ENDC"],
self.meta.color["GREEN"],
self.commands[com],
self.meta.color["ENDC"]))
self.msg.template(78)
try:
self.choice = raw_input(" > ")
except EOFError:
print("")
raise SystemExit()
if self.choice in self.commands.keys():
sys.stdout.write(" \x1b[1A{0}{1}{2}\n\n".format(
self.meta.color["CYAN"], self.commands[self.choice],
self.meta.color["ENDC"]))
sys.stdout.flush()
self.execute()
def execute(self):
"""Execute Slackware command
"""
if self.choice in self.commands.keys():
if self.choice == "i":
PackageManager(self.packages).install("")
elif self.choice in ["u", "r"]:
PackageManager(self.packages).upgrade(
self.commands[self.choice][11:])
class Auto(object):
"""Select Slackware command to install packages
"""
def __init__(self, packages):
self.packages = packages
self.meta = _meta_
self.msg = Msg()
self.commands = {
"i": "installpkg",
"u": "upgradepkg --install-new",
"r": "upgradepkg --reinstall"
}
def select(self):
"""Select Slackware command
"""
print("\nDetected Slackware binary package for installation:\n")
for pkg in self.packages:
print(" " + pkg.split("/")[-1])
print("")
self.msg.template(78)
print("| Choose a Slackware command:")
self.msg.template(78)
for com in sorted(self.commands):
print("| {0}{1}{2}) {3}{4}{5}".format(
self.meta.color["RED"], com, self.meta.color["ENDC"],
self.meta.color["GREEN"], self.commands[com],
self.meta.color["ENDC"]))
self.msg.template(78)
try:
self.choice = raw_input(" > ")
except EOFError:
print("")
raise SystemExit()
if self.choice in self.commands.keys():
sys.stdout.write(" \x1b[1A{0}{1}{2}\n\n".format(
self.meta.color["CYAN"], self.commands[self.choice],
self.meta.color["ENDC"]))
sys.stdout.flush()
self.execute()
def execute(self):
"""Execute Slackware command
"""
if self.choice in self.commands.keys():
if self.choice == "i":
PackageManager(self.packages).install("")
elif self.choice in ["u", "r"]:
PackageManager(self.packages).upgrade(
self.commands[self.choice][11:])
class TrackingDeps(object):
"""View tree of dependencies and also
highlight packages with color green
if already installed and color red
if not installed.
"""
def __init__(self, name, repo, flag):
self.name = name
self.repo = repo
self.flag = flag
self.meta = _meta_
self.msg = Msg()
self.green = self.meta.color["GREEN"]
self.yellow = self.meta.color["YELLOW"]
self.cyan = self.meta.color["CYAN"]
self.red = self.meta.color["RED"]
self.endc = self.meta.color["ENDC"]
self.requires = []
self.dependencies = []
self.dependencies_list = []
self.deps_dict = {}
for i in range(0, len(self.flag)):
if self.flag[i].startswith("--graph="):
self.image = self.flag[i].split("=")[1]
self.flag[i] = "--graph="
def run(self):
"""Run tracking dependencies
"""
self.msg.resolving()
self.repositories()
if self.find_pkg:
self.dependencies_list.reverse()
self.requires = Utils().dimensional_list(self.dependencies_list)
self.dependencies = Utils().remove_dbs(self.requires)
if self.dependencies == []:
self.dependencies = ["No dependencies"]
if "--graph=" in self.flag:
self.deps_tree()
self.msg.done()
pkg_len = len(self.name) + 24
print("") # new line at start
self.msg.template(pkg_len)
print("| Package {0}{1}{2} dependencies :".format(
self.cyan, self.name, self.endc))
self.msg.template(pkg_len)
print("\\")
print(" +---{0}[ Tree of dependencies ]{1}".format(
self.yellow, self.endc))
index = 0
for pkg in self.dependencies:
if "--check-deps" in self.flag:
used = self.check_used(pkg)
self.deps_used(pkg, used)
used = "{0} {1}{2}{3}".format("is dependency -->",
self.cyan, ", ".join(used),
self.endc)
else:
used = ""
index += 1
installed = ""
if find_package(pkg + self.meta.sp, self.meta.pkg_path):
if self.meta.use_colors in ["off", "OFF"]:
installed = "* "
print(" |")
print(" {0}{1}: {2}{3}{4} {5}{6}".format(
"+--", index, self.green, pkg, self.endc, installed,
used))
else:
print(" |")
print(" {0}{1}: {2}{3}{4} {5}".format(
"+--", index, self.red, pkg, self.endc, installed))
if self.meta.use_colors in ["off", "OFF"]:
print("\n * = Installed\n")
else:
print("") # new line at end
if "--graph=" in self.flag:
self.graph()
else:
self.msg.done()
print("\nNo package was found to match\n")
raise SystemExit(1)
def repositories(self):
"""Get dependencies by repositories
"""
if self.repo == "sbo":
self.sbo_case_insensitive()
self.find_pkg = sbo_search_pkg(self.name)
if self.find_pkg:
self.dependencies_list = Requires(self.flag).sbo(self.name)
else:
PACKAGES_TXT = Utils().read_file(
self.meta.lib_path + "{0}_repo/PACKAGES.TXT".format(self.repo))
self.names = Utils().package_name(PACKAGES_TXT)
self.bin_case_insensitive()
self.find_pkg = search_pkg(self.name, self.repo)
if self.find_pkg:
self.black = BlackList().packages(self.names, self.repo)
self.dependencies_list = Dependencies(self.repo,
self.black).binary(
self.name, self.flag)
def sbo_case_insensitive(self):
"""Matching packages distinguish between uppercase and
lowercase for sbo repository
"""
if "--case-ins" in self.flag:
data = SBoGrep(name="").names()
data_dict = Utils().case_sensitive(data)
for key, value in data_dict.iteritems():
if key == self.name.lower():
self.name = value
def bin_case_insensitive(self):
"""Matching packages distinguish between uppercase and
lowercase
"""
if "--case-ins" in self.flag:
data_dict = Utils().case_sensitive(self.names)
for key, value in data_dict.iteritems():
if key == self.name.lower():
self.name = value
def graph(self):
"""Drawing image dependencies map
"""
Graph(self.image).dependencies(self.deps_dict)
def check_used(self, pkg):
"""Check if dependencies used
"""
used = []
dep_path = self.meta.log_path + "dep/"
logs = find_package("", dep_path)
for log in logs:
deps = Utils().read_file(dep_path + log)
for dep in deps.splitlines():
if pkg == dep:
used.append(log)
return used
def deps_tree(self):
"""Package dependencies image map file
"""
dependencies = self.dependencies + [self.name]
if self.repo == "sbo":
for dep in dependencies:
deps = Requires(flag="").sbo(dep)
if dep not in self.deps_dict.values():
self.deps_dict[dep] = Utils().dimensional_list(deps)
else:
for dep in dependencies:
deps = Dependencies(self.repo, self.black).binary(dep, flag="")
if dep not in self.deps_dict.values():
self.deps_dict[dep] = Utils().dimensional_list(deps)
def deps_used(self, pkg, used):
"""Create dependencies dictionary
"""
if find_package(pkg + self.meta.sp, self.meta.pkg_path):
if pkg not in self.deps_dict.values():
self.deps_dict[pkg] = used
else:
self.deps_dict[pkg] += used
class BinaryInstall(object):
"""Install binaries packages with all dependencies from
repository
"""
def __init__(self, packages, repo, flag):
self.packages = packages
pkg_security(packages)
self.repo = repo
self.flag = flag
self.meta = _meta_
self.msg = Msg()
self.version = self.meta.slack_rel
self.tmp_path = self.meta.slpkg_tmp_packages
for fl in self.flag:
if fl.startswith("--directory-prefix="):
self.tmp_path = fl.split("=")[1]
if not self.tmp_path.endswith("/"):
self.tmp_path += "/"
self.dwn, self.dep_dwn = [], []
self.install, self.dep_install = [], []
self.comp_sum, self.dep_comp_sum = [], []
self.uncomp_sum, self.dep_uncomp_sum = [], []
self.dependencies = []
self.deps_dict = {}
self.answer = ""
self.msg.reading()
self.PACKAGES_TXT, self.mirror = RepoInit(self.repo).fetch()
self.data = repo_data(self.PACKAGES_TXT, self.repo, self.flag)
self.repo_pkg_names = []
for name in self.data[0]:
self.repo_pkg_names.append(split_package(name)[0])
self.blacklist = BlackList().packages(self.data[0], self.repo)
self.matching = False
def start(self, is_upgrade):
"""
Install packages from official Slackware distribution
"""
self.case_insensitive()
# fix if packages is for upgrade
self.is_upgrade = is_upgrade
mas_sum = dep_sum = sums = [0, 0, 0]
self.msg.done()
self.dependencies = self.resolving_deps()
self.update_deps()
(self.dep_dwn, self.dep_install, self.dep_comp_sum,
self.dep_uncomp_sum) = self.store(self.dependencies)
self.clear_masters()
(self.dwn, self.install, self.comp_sum,
self.uncomp_sum) = self.store(self.packages)
if (self.meta.rsl_deps in ["on", "ON"] and
"--resolve-off" not in self.flag):
self.msg.done()
if self.install:
print("\nThe following packages will be automatically "
"installed or upgraded \nwith new version:\n")
if self.matching:
self.msg.matching(self.packages)
self.top_view()
self.msg.upg_inst(self.is_upgrade)
mas_sum = self.views(self.install, self.comp_sum)
if self.dependencies:
print("Installing for dependencies:")
dep_sum = self.views(self.dep_install, self.dep_comp_sum)
# sums[0] --> installed
# sums[1] --> upgraded
# sums[2] --> uninstall
sums = [sum(i) for i in zip(mas_sum, dep_sum)]
unit, size = units(self.comp_sum + self.dep_comp_sum,
self.uncomp_sum + self.dep_uncomp_sum)
print("\nInstalling summary")
print("=" * 79)
print("{0}Total {1} {2}.".format(self.meta.color["GREY"],
sum(sums),
self.msg.pkg(sum(sums))))
print("{0} {1} will be installed, {2} will be upgraded and "
"{3} will be reinstalled.".format(sums[2],
self.msg.pkg(sums[2]),
sums[1], sums[0]))
print("Need to get {0} {1} of archives.".format(size[0],
unit[0]))
print("After this process, {0} {1} of additional disk "
"space will be used.{2}".format(size[1], unit[1],
self.meta.color["ENDC"]))
print("")
self.if_all_installed()
if self.msg.answer() in ["y", "Y"]:
for inst, dwn in zip(self.dep_install + self.install,
self.dep_dwn + self.dwn):
if (self.meta.not_downgrade == "on" and
self.not_downgrade(inst) is True):
continue
if (not os.path.isfile(self.meta.pkg_path + inst[:-4]) or
"--download-only" in self.flag or
"--reinstall" in self.flag):
Download(self.tmp_path, dwn.split(), self.repo).start()
else:
self.msg.template(78)
self.msg.pkg_found(inst)
self.msg.template(78)
if "--download-only" in self.flag:
raise SystemExit()
self.dep_install = Utils().check_downloaded(
self.tmp_path, self.dep_install)
self.install = Utils().check_downloaded(
self.tmp_path, self.install)
ins, upg = self.install_packages()
self.msg.reference(ins, upg)
write_deps(self.deps_dict)
delete_package(self.tmp_path, self.dep_install + self.install)
else:
self.msg.not_found(self.is_upgrade)
raise SystemExit(1)
def if_all_installed(self):
"""Check if all packages is already installed
"""
count_inst = 0
for inst in (self.dep_install + self.install):
if (os.path.isfile(self.meta.pkg_path + inst[:-4]) and
"--download-only" not in self.flag):
count_inst += 1
if (count_inst == len(self.dep_install + self.install) and
"--reinstall" not in self.flag):
raise SystemExit()
def case_insensitive(self):
"""Matching packages distinguish between uppercase and
lowercase
"""
if "--case-ins" in self.flag:
data = []
data = Utils().package_name(self.PACKAGES_TXT)
data_dict = Utils().case_sensitive(data)
for pkg in self.packages:
index = self.packages.index(pkg)
for key, value in data_dict.iteritems():
if key == pkg.lower():
self.packages[index] = value
def update_deps(self):
"""Update dependencies dictionary with all package
"""
for dep in self.dependencies:
deps = Utils().dimensional_list(Dependencies(
self.repo, self.blacklist).binary(
dep, self.flag))
self.deps_dict[dep] = deps
def clear_masters(self):
"""Clear master packages if already exist in dependencies
or if added to install two or more times
"""
packages = []
for mas in Utils().remove_dbs(self.packages):
if mas not in self.dependencies:
packages.append(mas)
self.packages = packages
def install_packages(self):
"""Install or upgrade packages
"""
installs, upgraded = [], []
for inst in (self.dep_install + self.install):
package = (self.tmp_path + inst).split()
pkg_ver = "{0}-{1}".format(split_package(inst)[0],
split_package(inst)[1])
self.checksums(inst)
if GetFromInstalled(split_package(inst)[0]).name():
print("[ {0}upgrading{1} ] --> {2}".format(
self.meta.color["YELLOW"], self.meta.color["ENDC"], inst))
upgraded.append(pkg_ver)
if "--reinstall" in self.flag:
PackageManager(package).upgrade("--reinstall")
else:
PackageManager(package).upgrade("--install-new")
else:
print("[ {0}installing{1} ] --> {2}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"], inst))
installs.append(pkg_ver)
PackageManager(package).upgrade("--install-new")
return [installs, upgraded]
def not_downgrade(self, package):
"""Don't downgrade packages if repository version is lower than
installed"""
name = split_package(package)[0]
rep_ver = split_package(package)[1]
ins_ver = GetFromInstalled(name).version()[1:]
if not ins_ver:
ins_ver = "0"
if LooseVersion(rep_ver) < LooseVersion(ins_ver):
self.msg.template(78)
print("| Package {0} don't downgrade, "
"setting by user".format(name))
self.msg.template(78)
return True
def checksums(self, install):
"""Checksums before install
"""
check_md5(pkg_checksum(install, self.repo), self.tmp_path + install)
def resolving_deps(self):
"""Return package dependencies
"""
requires = []
if (self.meta.rsl_deps in ["on", "ON"] and
self.flag != "--resolve-off"):
self.msg.resolving()
for dep in self.packages:
status(0.05)
dependencies = []
dependencies = Utils().dimensional_list(Dependencies(
self.repo, self.blacklist).binary(dep, self.flag))
requires += self._fix_deps_repos(dependencies)
self.deps_dict[dep] = Utils().remove_dbs(requires)
return Utils().remove_dbs(requires)
def _fix_deps_repos(self, dependencies):
"""Fix store deps include in repository
"""
requires = []
for dep in dependencies:
if dep in self.repo_pkg_names:
requires.append(dep)
return requires
def views(self, install, comp_sum):
"""Views packages
"""
pkg_sum = uni_sum = upg_sum = 0
# fix repositories align
repo = self.repo + (" " * (6 - (len(self.repo))))
for pkg, comp in zip(install, comp_sum):
pkg_repo = split_package(pkg[:-4])
if find_package(pkg[:-4], self.meta.pkg_path):
pkg_sum += 1
COLOR = self.meta.color["GREEN"]
elif pkg_repo[0] == GetFromInstalled(pkg_repo[0]).name():
COLOR = self.meta.color["YELLOW"]
upg_sum += 1
else:
COLOR = self.meta.color["RED"]
uni_sum += 1
ver = GetFromInstalled(pkg_repo[0]).version()
print(" {0}{1}{2}{3} {4}{5} {6}{7}{8}{9}{10}{11:>11}{12}".format(
COLOR, pkg_repo[0] + ver, self.meta.color["ENDC"],
" " * (23-len(pkg_repo[0] + ver)), pkg_repo[1],
" " * (18-len(pkg_repo[1])), pkg_repo[2],
" " * (8-len(pkg_repo[2])), pkg_repo[3],
" " * (7-len(pkg_repo[3])), repo,
comp, " K")).rstrip()
return [pkg_sum, upg_sum, uni_sum]
def top_view(self):
"""Print packages status bar
"""
self.msg.template(78)
print("{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}".format(
"| Package", " " * 17,
"New Version", " " * 8,
"Arch", " " * 4,
"Build", " " * 2,
"Repos", " " * 10,
"Size"))
self.msg.template(78)
def store(self, packages):
"""Store and return packages for install
"""
dwn, install, comp_sum, uncomp_sum = ([] for i in range(4))
# name = data[0]
# location = data[1]
# size = data[2]
# unsize = data[3]
for pkg in packages:
for pk, loc, comp, uncomp in zip(self.data[0], self.data[1],
self.data[2], self.data[3]):
if (pk and pkg == split_package(pk)[0] and
pk not in install and
split_package(pk)[0] not in self.blacklist):
dwn.append("{0}{1}/{2}".format(self.mirror, loc, pk))
install.append(pk)
comp_sum.append(comp)
uncomp_sum.append(uncomp)
if not install:
for pkg in packages:
for pk, loc, comp, uncomp in zip(self.data[0], self.data[1],
self.data[2], self.data[3]):
name = split_package(pk)[0]
if (pk and pkg in name and name not in self.blacklist):
self.matching = True
dwn.append("{0}{1}/{2}".format(self.mirror, loc, pk))
install.append(pk)
comp_sum.append(comp)
uncomp_sum.append(uncomp)
dwn.reverse()
install.reverse()
comp_sum.reverse()
uncomp_sum.reverse()
if self.repo == "slack":
dwn, install, comp_sum, uncomp_sum = self.patches(dwn, install,
comp_sum,
uncomp_sum)
return [dwn, install, comp_sum, uncomp_sum]
def patches(self, dwn, install, comp_sum, uncomp_sum):
"""Seperates packages from patches/ directory
"""
dwnp, installp, comp_sump, uncomp_sump = ([] for i in range(4))
for d, i, c, u in zip(dwn, install, comp_sum, uncomp_sum):
if "_slack" + slack_ver() in i:
dwnp.append(d)
dwn.remove(d)
installp.append(i)
install.remove(i)
comp_sump.append(c)
comp_sum.remove(c)
uncomp_sump.append(u)
uncomp_sum.remove(u)
if "--patches" in self.flag:
return dwnp, installp, comp_sump, uncomp_sump
return dwn, install, comp_sum, uncomp_sum
class DependenciesStatus(object):
"""Print dependencies status used by packages
"""
def __init__(self, image):
self.image = image
self.meta = _meta_
self.msg = Msg()
self.grey = self.meta.color["GREY"]
self.green = self.meta.color["GREEN"]
self.endc = self.meta.color["ENDC"]
self.dmap = {}
self.count_pkg = 0
self.count_dep = 0
self.dep_path = self.meta.log_path + "dep/"
self.logs = find_package("", self.dep_path)
if not self.logs:
self.no_logs()
self.installed = find_package("", self.meta.pkg_path)
def data(self):
"""Check all installed packages and create
dictionary database
"""
for pkg in self.installed:
if os.path.isfile(self.meta.pkg_path + pkg):
name = split_package(pkg)[0]
for log in self.logs:
deps = Utils().read_file(self.dep_path + log)
for dep in deps.splitlines():
if name == dep:
if name not in self.dmap.keys():
self.dmap[name] = [log]
self.count_dep += 1
else:
self.dmap[name] += [log]
self.count_pkg += 1
def show(self):
"""Show dependencies status
"""
self.data()
print("")
self.msg.template(78)
print("| {0}{1}{2}".format("Dependencies", " " * 20, "Packages"))
self.msg.template(78)
for key, value in self.dmap.iteritems():
print(" {0}{1}{2}{3}{4}".format(
self.green, key, self.endc, " " * (32-len(key)),
", ".join(value)))
self.summary()
if self.image:
Graph(self.image).dependencies(self.dmap)
def tree(self):
"""Like tree view mode
"""
self.msg.template(78)
print("| Dependencies\n"
"| Packages")
self.msg.template(78)
self.data()
for pkg, dep in self.dmap.iteritems():
print("+ {0}{1}{2}".format(self.green, pkg, self.endc))
print("|")
for d in dep:
print("+-- {0}".format(d))
print("|")
sys.stdout.write("\x1b[1A{0}\n".format(" "))
sys.stdout.flush()
self.summary()
def no_logs(self):
"""Print message if no logs found
"""
print("\n There were no logs files. Obviously not used the\n"
" installation method with the command:\n"
" '$ slpkg -s <repository> <packages>' yet.\n")
raise SystemExit()
def summary(self):
"""Summary by packages and dependencies
"""
print("\nStatus summary")
print("=" * 79)
print("{0}found {1} dependencies in {2} packages.{3}\n".format(
self.grey, self.count_dep, self.count_pkg, self.endc))
class RepoEnable(object):
"""Read repositories.conf file and update with new enabled or
disabled repositories
"""
def __init__(self):
self.meta = _meta_
self.msg = Msg()
self.tag = "[REPOSITORIES]"
self.tag_line = False
self.repositories_conf = "repositories.conf"
self.conf = Utils().read_file(
self.meta.conf_path + self.repositories_conf)
self.enabled = []
self.disabled = []
self.selected = []
def choose(self):
"""Choose repositories
"""
keys = """
Choose repositories at the right side for enable or to the
left side for disable.
Keys: SPACE select or deselect the highlighted repositories,
move it between the left and right lists
^ move the focus to the left list
$ move the focus to the right list
TAB move focus
ENTER press the focused button
Disabled <-------- REPOSITORIES -------> Enabled"""
self.read_enabled()
self.read_disabled()
text, title, backtitle, status = keys, " Repositories ", "", False
self.selected = DialogUtil(self.disabled, text, title, backtitle,
status).buildlist(self.enabled)
if self.selected is not None:
self.update_repos()
else:
self.selected = self.enabled
self.clear_screen()
self.reference()
def read_enabled(self):
"""Read enable repositories
"""
for line in self.conf.splitlines():
line = line.lstrip()
if self.tag in line:
self.tag_line = True
if (line and self.tag_line and not line.startswith("#") and
self.tag not in line):
self.enabled.append(line)
self.tag_line = False
def read_disabled(self):
"""Read disable repositories
"""
for line in self.conf.splitlines():
line = line.lstrip()
if self.tag in line:
self.tag_line = True
if self.tag_line and line.startswith("#"):
line = "".join(line.split("#")).strip()
self.disabled.append(line)
self.tag_line = False
def update_repos(self):
"""Update repositories.conf file with enabled or disabled
repositories
"""
with open("{0}{1}".format(self.meta.conf_path,
self.repositories_conf), "w") as new_conf:
for line in self.conf.splitlines():
line = line.lstrip()
if self.tag in line:
self.tag_line = True
if self.tag_line and line.startswith("#"):
repo = "".join(line.split("#")).strip()
if repo in self.selected:
new_conf.write(line.replace(line, repo + "\n"))
continue
if (self.tag_line and not line.startswith("#") and
line != self.tag):
repo = line.strip()
if repo not in self.selected:
new_conf.write(line.replace(line, "# " + line + "\n"))
continue
new_conf.write(line + "\n")
def clear_screen(self):
"""Clear screen
"""
os.system("clear")
def reference(self):
"""Reference enable repositories
"""
total_enabled = ", ".join(self.selected)
if len(total_enabled) < 1:
total_enabled = ("{0}Are you crazy? This is a package "
"manager for packages :p{1}".format(
self.meta.color["RED"],
self.meta.color["ENDC"]))
self.msg.template(78)
print("| Enabled repositories:")
self.msg.template(78)
print("| {0}".format(total_enabled))
self.msg.template(78)
print("{0}Total {1}/{2} repositories enabled.{3}\n".format(
self.meta.color["GREY"], len(self.selected),
len(self.enabled + self.disabled), self.meta.color["ENDC"]))
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 TrackingDeps(object):
"""View tree of dependencies and also
highlight packages with color green
if already installed and color red
if not installed.
"""
def __init__(self, name, repo, flag):
self.name = name
self.repo = repo
self.flag = flag
self.meta = _meta_
self.msg = Msg()
self.green = self.meta.color["GREEN"]
self.yellow = self.meta.color["YELLOW"]
self.cyan = self.meta.color["CYAN"]
self.red = self.meta.color["RED"]
self.endc = self.meta.color["ENDC"]
self.requires = []
self.dependencies = []
self.dependencies_list = []
self.deps_dict = {}
for i in range(0, len(self.flag)):
if self.flag[i].startswith("--graph="):
self.image = self.flag[i].split("=")[1]
self.flag[i] = "--graph="
def run(self):
"""Run tracking dependencies
"""
self.msg.resolving()
self.repositories()
if self.find_pkg:
self.dependencies_list.reverse()
self.requires = Utils().dimensional_list(self.dependencies_list)
self.dependencies = Utils().remove_dbs(self.requires)
if self.dependencies == []:
self.dependencies = ["No dependencies"]
if "--graph=" in self.flag:
self.deps_tree()
self.msg.done()
pkg_len = len(self.name) + 24
print("") # new line at start
self.msg.template(pkg_len)
print("| Package {0}{1}{2} dependencies :".format(
self.cyan, self.name, self.endc))
self.msg.template(pkg_len)
print("\\")
print(" +---{0}[ Tree of dependencies ]{1}".format(self.yellow,
self.endc))
index = 0
for pkg in self.dependencies:
if "--check-deps" in self.flag:
used = self.check_used(pkg)
self.deps_used(pkg, used)
used = "{0} {1}{2}{3}".format(
"is dependency -->", self.cyan,
", ".join(used), self.endc)
else:
used = ""
index += 1
installed = ""
if find_package(pkg + self.meta.sp, self.meta.pkg_path):
if self.meta.use_colors in ["off", "OFF"]:
installed = "* "
print(" |")
print(" {0}{1}: {2}{3}{4} {5}{6}".format(
"+--", index, self.green, pkg,
self.endc, installed, used))
else:
print(" |")
print(" {0}{1}: {2}{3}{4} {5}".format(
"+--", index, self.red, pkg,
self.endc, installed))
if self.meta.use_colors in ["off", "OFF"]:
print("\n * = Installed\n")
else:
print("") # new line at end
if "--graph=" in self.flag:
self.graph()
else:
self.msg.done()
print("\nNo package was found to match\n")
def repositories(self):
"""Get dependencies by repositories
"""
if self.repo == "sbo":
self.sbo_case_insensitive()
self.find_pkg = sbo_search_pkg(self.name)
if self.find_pkg:
self.dependencies_list = Requires(self.flag).sbo(self.name)
else:
PACKAGES_TXT = Utils().read_file(
self.meta.lib_path + "{0}_repo/PACKAGES.TXT".format(self.repo))
self.names = Utils().package_name(PACKAGES_TXT)
self.bin_case_insensitive()
self.find_pkg = search_pkg(self.name, self.repo)
if self.find_pkg:
self.black = BlackList().packages(self.names, self.repo)
self.dependencies_list = Dependencies(
self.names, self.repo, self.black).binary(self.name,
self.flag)
def sbo_case_insensitive(self):
"""Matching packages distinguish between uppercase and
lowercase for sbo repository
"""
if "--case-ins" in self.flag:
data = SBoGrep(name="").names()
data_dict = Utils().case_sensitive(data)
for key, value in data_dict.iteritems():
if key == self.name.lower():
self.name = value
def bin_case_insensitive(self):
"""Matching packages distinguish between uppercase and
lowercase
"""
if "--case-ins" in self.flag:
data_dict = Utils().case_sensitive(self.names)
for key, value in data_dict.iteritems():
if key == self.name.lower():
self.name = value
def graph(self):
"""Drawing image dependencies map
"""
Graph(self.image).dependencies(self.deps_dict)
def check_used(self, pkg):
"""Check if dependencies used
"""
used = []
dep_path = self.meta.log_path + "dep/"
logs = find_package("", dep_path)
for log in logs:
deps = Utils().read_file(dep_path + log)
for dep in deps.splitlines():
if pkg == dep:
used.append(log)
return used
def deps_tree(self):
"""Package dependencies image map file
"""
dependencies = self.dependencies + [self.name]
if self.repo == "sbo":
for dep in dependencies:
deps = Requires(flag="").sbo(dep)
if dep not in self.deps_dict.values():
self.deps_dict[dep] = Utils().dimensional_list(deps)
else:
for dep in dependencies:
deps = Dependencies(self.names, self.repo,
self.black).binary(dep, flag="")
if dep not in self.deps_dict.values():
self.deps_dict[dep] = Utils().dimensional_list(deps)
def deps_used(self, pkg, used):
"""Create dependencies dictionary
"""
if find_package(pkg + self.meta.sp, self.meta.pkg_path):
if pkg not in self.deps_dict.values():
self.deps_dict[pkg] = used
else:
self.deps_dict[pkg] += used
class RepoEnable(object):
"""Read repositories.conf file and update with new enabled or
disabled repositories
"""
def __init__(self):
self.meta = _meta_
self.msg = Msg()
self.tag = "[REPOSITORIES]"
self.tag_line = False
self.repositories_conf = "repositories.conf"
self.conf = Utils().read_file(
self.meta.conf_path + self.repositories_conf)
self.enabled = []
self.disabled = []
self.selected = []
def choose(self):
"""Choose repositories
"""
keys = """
Choose repositories at the right side for enable or to the
left side for disable.
Keys: SPACE select or deselect the highlighted repositories,
move it between the left and right lists
^ move the focus to the left list
$ move the focus to the right list
TAB move focus
ENTER press the focused button
Disabled <-------- REPOSITORIES -------> Enabled"""
self.read_enabled()
self.read_disabled()
text, title, backtitle, status = keys, "Repositories", "", False
self.selected = DialogUtil(self.disabled, text, title, backtitle,
status).buildlist(self.enabled)
if self.selected is not None:
self.update_repos()
else:
self.selected = self.enabled
self.clear_screen()
self.reference()
def read_enabled(self):
"""Read enable repositories
"""
for line in self.conf.splitlines():
line = line.lstrip()
if self.tag in line:
self.tag_line = True
if (line and self.tag_line and not line.startswith("#") and
self.tag not in line):
self.enabled.append(line)
self.tag_line = False
def read_disabled(self):
"""Read disable repositories
"""
for line in self.conf.splitlines():
line = line.lstrip()
if self.tag in line:
self.tag_line = True
if self.tag_line and line.startswith("#"):
line = "".join(line.split("#")).strip()
self.disabled.append(line)
self.tag_line = False
def update_repos(self):
"""Update repositories.conf file with enabled or disabled
repositories
"""
with open("{0}{1}".format(self.meta.conf_path,
self.repositories_conf), "w") as new_conf:
for line in self.conf.splitlines():
line = line.lstrip()
if self.tag in line:
self.tag_line = True
if self.tag_line and line.startswith("#"):
repo = "".join(line.split("#")).strip()
if repo in self.selected:
new_conf.write(line.replace(line, repo + "\n"))
continue
if (self.tag_line and not line.startswith("#") and
line != self.tag):
repo = line.strip()
if repo not in self.selected:
new_conf.write(line.replace(line, "# " + line + "\n"))
continue
new_conf.write(line + "\n")
def clear_screen(self):
"""Clear screen
"""
os.system("clear")
def reference(self):
"""Reference enable repositories
"""
total_enabled = ", ".join(self.selected)
if len(total_enabled) < 1:
total_enabled = ("{0}Are you crazy? This is a package "
"manager for packages :p{1}".format(
self.meta.color["RED"],
self.meta.color["ENDC"]))
self.msg.template(78)
print("| Enabled repositories:")
self.msg.template(78)
print("| {0}".format(total_enabled))
self.msg.template(78)
print("{0}Total {1}/{2} repositories enabled.{3}\n".format(
self.meta.color["GREY"], len(self.selected),
len(self.enabled + self.disabled), self.meta.color["ENDC"]))
class DependenciesStatus(object):
"""Print dependencies status used by packages
"""
def __init__(self, image):
self.image = image
self.meta = _meta_
self.msg = Msg()
self.grey = self.meta.color["GREY"]
self.green = self.meta.color["GREEN"]
self.endc = self.meta.color["ENDC"]
self.dmap = {}
self.count_pkg = 0
self.count_dep = 0
self.dep_path = self.meta.log_path + "dep/"
self.logs = find_package("", self.dep_path)
if not self.logs:
self.no_logs()
self.installed = find_package("", self.meta.pkg_path)
def data(self):
"""Check all installed packages and create
dictionary database
"""
for pkg in self.installed:
if os.path.isfile(self.meta.pkg_path + pkg):
name = split_package(pkg)[0]
for log in self.logs:
deps = Utils().read_file(self.dep_path + log)
for dep in deps.splitlines():
if name == dep:
if name not in self.dmap.keys():
self.dmap[name] = [log]
if not self.count_pkg:
self.count_pkg = 1
else:
self.dmap[name] += [log]
self.count_packages()
def count_packages(self):
"""Count dependencies and packages
"""
packages = []
for pkg in self.dmap.values():
packages += pkg
self.count_dep += 1
self.count_pkg = len(set(packages))
def show(self):
"""Show dependencies status
"""
self.data()
print("")
self.msg.template(78)
print("| {0}{1}{2}".format("Dependencies", " " * 20, "Packages"))
self.msg.template(78)
for key, value in self.dmap.iteritems():
print(" {0}{1}{2}{3}{4}".format(self.green, key, self.endc,
" " * (32 - len(key)),
", ".join(value)))
self.summary()
if self.image:
Graph(self.image).dependencies(self.dmap)
def tree(self):
"""Like tree view mode
"""
self.msg.template(78)
print("| Dependencies\n" "| -- Packages")
self.msg.template(78)
self.data()
for pkg, dep in self.dmap.iteritems():
print("+ {0}{1}{2}".format(self.green, pkg, self.endc))
print("|")
for d in dep:
print("+-- {0}".format(d))
print("|")
sys.stdout.write("\x1b[1A{0}\n".format(" "))
sys.stdout.flush()
self.summary()
if self.image:
Graph(self.image).dependencies(self.dmap)
def no_logs(self):
"""Print message if no logs found
"""
print("\n There were no logs files. Obviously not used the\n"
" installation method with the command:\n"
" '$ slpkg -s <repository> <packages>' yet.\n")
raise SystemExit()
def summary(self):
"""Summary by packages and dependencies
"""
print("\nStatus summary")
print("=" * 79)
print("{0}found {1} dependencies in {2} packages.{3}\n".format(
self.grey, self.count_dep, self.count_pkg, self.endc))
class BinaryInstall(object):
"""Install binaries packages with all dependencies from
repository
"""
def __init__(self, packages, repo, flag):
self.packages = packages
self.repo = repo
self.flag = flag
self.meta = _meta_
self.msg = Msg()
self.version = self.meta.slack_rel
self.tmp_path = self.meta.slpkg_tmp_packages
for fl in self.flag:
if fl.startswith("--directory-prefix="):
self.tmp_path = fl.split("=")[1]
if not self.tmp_path.endswith("/"):
self.tmp_path += "/"
self.dwn, self.dep_dwn = [], []
self.install, self.dep_install = [], []
self.comp_sum, self.dep_comp_sum = [], []
self.uncomp_sum, self.dep_uncomp_sum = [], []
self.dependencies = []
self.deps_dict = {}
self.answer = ""
self.msg.reading()
self.PACKAGES_TXT, self.mirror = RepoInit(self.repo).fetch()
self.data = repo_data(self.PACKAGES_TXT, self.repo, self.flag)
self.blacklist = BlackList().packages(self.data[0], self.repo)
def start(self, if_upgrade):
"""
Install packages from official Slackware distribution
"""
self.case_insensitive()
# fix if packages is for upgrade
self.if_upgrade = if_upgrade
mas_sum = dep_sum = sums = [0, 0, 0]
self.msg.done()
self.dependencies = self.resolving_deps()
self.update_deps()
(self.dep_dwn, self.dep_install, self.dep_comp_sum,
self.dep_uncomp_sum) = self.store(self.dependencies)
self.clear_masters()
(self.dwn, self.install, self.comp_sum,
self.uncomp_sum) = self.store(self.packages)
if (self.meta.rsl_deps in ["on", "ON"] and
"--resolve-off" not in self.flag):
self.msg.done()
if self.install:
print("\nThe following packages will be automatically "
"installed or upgraded \nwith new version:\n")
self.top_view()
self.msg.upg_inst(self.if_upgrade)
mas_sum = self.views(self.install, self.comp_sum)
if self.dependencies:
print("Installing for dependencies:")
dep_sum = self.views(self.dep_install, self.dep_comp_sum)
# sums[0] --> installed
# sums[1] --> upgraded
# sums[2] --> uninstall
sums = [sum(i) for i in zip(mas_sum, dep_sum)]
unit, size = units(self.comp_sum + self.dep_comp_sum,
self.uncomp_sum + self.dep_uncomp_sum)
print("\nInstalling summary")
print("=" * 79)
print("{0}Total {1} {2}.".format(self.meta.color["GREY"],
sum(sums),
self.msg.pkg(sum(sums))))
print("{0} {1} will be installed, {2} will be upgraded and "
"{3} will be reinstalled.".format(sums[2],
self.msg.pkg(sums[2]),
sums[1], sums[0]))
print("Need to get {0} {1} of archives.".format(size[0],
unit[0]))
print("After this process, {0} {1} of additional disk "
"space will be used.{2}".format(size[1], unit[1],
self.meta.color["ENDC"]))
print("")
if self.msg.answer() in ["y", "Y"]:
self.install.reverse()
Download(self.tmp_path, self.dep_dwn + self.dwn,
self.repo).start()
if "--download-only" in self.flag:
raise SystemExit()
self.dep_install = Utils().check_downloaded(
self.tmp_path, self.dep_install)
self.install = Utils().check_downloaded(
self.tmp_path, self.install)
ins, upg = self.install_packages()
self.msg.reference(ins, upg)
write_deps(self.deps_dict)
delete_package(self.tmp_path, self.install)
else:
self.msg.not_found(self.if_upgrade)
def case_insensitive(self):
"""Matching packages distinguish between uppercase and
lowercase
"""
if "--case-ins" in self.flag:
data = []
data = Utils().package_name(self.PACKAGES_TXT)
data_dict = Utils().case_sensitive(data)
for pkg in self.packages:
index = self.packages.index(pkg)
for key, value in data_dict.iteritems():
if key == pkg.lower():
self.packages[index] = value
def update_deps(self):
"""Update dependencies dictionary with all package
"""
for dep in self.dependencies:
deps = Utils().dimensional_list(Dependencies(
self.PACKAGES_TXT, self.repo, self.blacklist).binary(
dep, self.flag))
self.deps_dict[dep] = deps
def clear_masters(self):
"""Clear master packages if already exist in dependencies
or if added to install two or more times
"""
packages = []
for mas in Utils().remove_dbs(self.packages):
if mas not in self.dependencies:
packages.append(mas)
self.packages = packages
def install_packages(self):
"""Install or upgrade packages
"""
installs, upgraded = [], []
for inst in (self.dep_install + self.install):
package = (self.tmp_path + inst).split()
pkg_ver = "{0}-{1}".format(split_package(inst)[0],
split_package(inst)[1])
self.checksums(inst)
if os.path.isfile(self.meta.pkg_path + inst[:-4]):
print("[ {0}reinstalling{1} ] --> {2}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"], inst))
installs.append(pkg_ver)
PackageManager(package).upgrade("--reinstall")
elif GetFromInstalled(split_package(inst)[0]).name():
print("[ {0}upgrading{1} ] --> {2}".format(
self.meta.color["YELLOW"], self.meta.color["ENDC"], inst))
upgraded.append(pkg_ver)
PackageManager(package).upgrade("--install-new")
else:
print("[ {0}installing{1} ] --> {2}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"], inst))
installs.append(pkg_ver)
PackageManager(package).upgrade("--install-new")
return [installs, upgraded]
def checksums(self, install):
"""Checksums before install
"""
check_md5(pkg_checksum(install, self.repo), self.tmp_path + install)
def resolving_deps(self):
"""Return package dependencies
"""
requires = []
if (self.meta.rsl_deps in ["on", "ON"] and
self.flag != "--resolve-off"):
self.msg.resolving()
for dep in self.packages:
status(0.05)
dependencies = []
dependencies = Utils().dimensional_list(Dependencies(
self.PACKAGES_TXT, self.repo, self.blacklist).binary(
dep, self.flag))
requires += dependencies
self.deps_dict[dep] = Utils().remove_dbs(dependencies)
return Utils().remove_dbs(requires)
def views(self, install, comp_sum):
"""Views packages
"""
pkg_sum = uni_sum = upg_sum = 0
# fix repositories align
repo = self.repo + (" " * (6 - (len(self.repo))))
for pkg, comp in zip(install, comp_sum):
pkg_repo = split_package(pkg[:-4])
if find_package(pkg[:-4], self.meta.pkg_path):
pkg_sum += 1
COLOR = self.meta.color["GREEN"]
elif pkg_repo[0] == GetFromInstalled(pkg_repo[0]).name():
COLOR = self.meta.color["YELLOW"]
upg_sum += 1
else:
COLOR = self.meta.color["RED"]
uni_sum += 1
ver = GetFromInstalled(pkg_repo[0]).version()
print(" {0}{1}{2}{3} {4}{5} {6}{7}{8}{9}{10}{11:>11}{12}".format(
COLOR, pkg_repo[0] + ver, self.meta.color["ENDC"],
" " * (23-len(pkg_repo[0] + ver)), pkg_repo[1],
" " * (18-len(pkg_repo[1])), pkg_repo[2],
" " * (8-len(pkg_repo[2])), pkg_repo[3],
" " * (7-len(pkg_repo[3])), repo,
comp, " K")).rstrip()
return [pkg_sum, upg_sum, uni_sum]
def top_view(self):
"""Print packages status bar
"""
self.msg.template(78)
print("{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}".format(
"| Package", " " * 17,
"New Version", " " * 8,
"Arch", " " * 4,
"Build", " " * 2,
"Repos", " " * 10,
"Size"))
self.msg.template(78)
def store(self, packages):
"""Store and return packages for install
"""
dwn, install, comp_sum, uncomp_sum = ([] for i in range(4))
# name = data[0]
# location = data[1]
# size = data[2]
# unsize = data[3]
for pkg in packages:
for pk, loc, comp, uncomp in zip(self.data[0], self.data[1],
self.data[2], self.data[3]):
if (pk and pkg == split_package(pk)[0] and
pk not in install and
split_package(pk)[0] not in self.blacklist):
dwn.append("{0}{1}/{2}".format(self.mirror, loc, pk))
install.append(pk)
comp_sum.append(comp)
uncomp_sum.append(uncomp)
if not install:
for pkg in packages:
for pk, loc, comp, uncomp in zip(self.data[0], self.data[1],
self.data[2], self.data[3]):
name = split_package(pk)[0]
if (pk and pkg in name and name not in self.blacklist):
dwn.append("{0}{1}/{2}".format(self.mirror, loc, pk))
install.append(pk)
comp_sum.append(comp)
uncomp_sum.append(uncomp)
dwn.reverse()
install.reverse()
comp_sum.reverse()
uncomp_sum.reverse()
return [dwn, install, comp_sum, uncomp_sum]
class Patches(object):
"""Upgrade distribution from official Slackware mirrors
"""
def __init__(self, skip, flag):
self.skip = skip
self.flag = flag
self.meta = _meta_
self.msg = Msg()
self.version = self.meta.slack_rel
self.patch_path = self.meta.slpkg_tmp_patches
self.pkg_for_upgrade = []
self.dwn_links = []
self.upgrade_all = []
self.count_added = 0
self.count_upg = 0
self.upgraded = []
self.installed = []
self.comp_sum = []
self.uncomp_sum = []
self.utils = Utils()
self.msg.checking()
if self.version == "stable":
self.PACKAGES_TXT = URL(mirrors("PACKAGES.TXT",
"patches/")).reading()
else:
self.PACKAGES_TXT = URL(mirrors("PACKAGES.TXT", "")).reading()
def start(self):
"""
Install new patches from official Slackware mirrors
"""
self.store()
self.msg.done()
if self.upgrade_all:
if "--checklist" in self.flag:
self.dialog_checklist()
print("\nThese packages need upgrading:\n")
self.msg.template(78)
print("{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}".format(
"| Package", " " * 17,
"New Version", " " * 8,
"Arch", " " * 4,
"Build", " " * 2,
"Repos", " " * 10,
"Size"))
self.msg.template(78)
print("Upgrading:")
self.views()
unit, size = units(self.comp_sum, self.uncomp_sum)
print("\nInstalling summary")
print("=" * 79)
print("{0}Total {1} {2} will be upgraded and {3} will be "
"installed.".format(self.meta.color["GREY"],
self.count_upg,
self.msg.pkg(self.upgrade_all),
self.count_added))
print("Need to get {0} {1} of archives.".format(size[0],
unit[0]))
print("After this process, {0} {1} of additional disk space "
"will be used.{2}".format(size[1], unit[1],
self.meta.color["ENDC"]))
print("")
if self.msg.answer() in ["y", "Y"]:
Download(self.patch_path, self.dwn_links,
repo="slack").start()
self.upgrade_all = self.utils.check_downloaded(
self.patch_path, self.upgrade_all)
self.upgrade()
self.kernel()
if self.meta.slackpkg_log in ["on", "ON"]:
self.slackpkg_update()
self.msg.reference(self.installed, self.upgraded)
delete_package(self.patch_path, self.upgrade_all)
self.update_lists()
else:
slack_arch = ""
if self.meta.arch == "x86_64":
slack_arch = "64"
print("\nSlackware{0} '{1}' v{2} distribution is up to "
"date\n".format(slack_arch, self.version, slack_ver()))
def store(self):
"""
Store and return packages for upgrading
"""
data = repo_data(self.PACKAGES_TXT, "slack", self.flag)
black = BlackList().packages(pkgs=data[0], repo="slack")
for name, loc, comp, uncomp in zip(data[0], data[1], data[2], data[3]):
status(0.0003)
repo_pkg_name = split_package(name)[0]
if (not os.path.isfile(self.meta.pkg_path + name[:-4]) and
repo_pkg_name not in black and
repo_pkg_name not in self.skip):
self.dwn_links.append("{0}{1}/{2}".format(mirrors("", ""),
loc, name))
self.comp_sum.append(comp)
self.uncomp_sum.append(uncomp)
self.upgrade_all.append(name)
self.count_upg += 1
if not find_package(repo_pkg_name + self.meta.sp,
self.meta.pkg_path):
self.count_added += 1
self.count_upg -= 1
return self.count_upg
def dialog_checklist(self):
"""Create checklist to choose packages for upgrade
"""
data = []
for upg in self.upgrade_all:
data.append(upg[:-4])
text = "Press 'spacebar' to unchoose packages from upgrade"
title = "Upgrade"
backtitle = "{0} {1}".format(self.meta.__all__,
self.meta.__version__)
status = True
pkgs = DialogUtil(data, text, title, backtitle,
status).checklist()
index = 0
for pkg, comp, uncomp in zip(self.upgrade_all, self.comp_sum,
self.uncomp_sum):
if pkg[:-4] not in pkgs:
self.dwn_links.pop(index)
self.upgrade_all.pop(index)
self.comp_sum.pop(index)
self.uncomp_sum.pop(index)
self.count_upg -= 1
index -= 1
index += 1
if not self.upgrade_all:
raise SystemExit()
def views(self):
"""
Views packages
"""
for upg, size in sorted(zip(self.upgrade_all, self.comp_sum)):
pkg_repo = split_package(upg[:-4])
color = self.meta.color["RED"]
pkg_inst = GetFromInstalled(pkg_repo[0]).name()
if pkg_repo[0] == pkg_inst:
color = self.meta.color["YELLOW"]
ver = GetFromInstalled(pkg_repo[0]).version()
print(" {0}{1}{2}{3} {4}{5} {6}{7}{8}{9}{10}{11:>12}{12}".format(
color, pkg_repo[0] + ver, self.meta.color["ENDC"],
" " * (23-len(pkg_repo[0] + ver)), pkg_repo[1],
" " * (18-len(pkg_repo[1])), pkg_repo[2],
" " * (8-len(pkg_repo[2])), pkg_repo[3],
" " * (7-len(pkg_repo[3])), "Slack",
size, " K")).rstrip()
def upgrade(self):
"""
Upgrade packages
"""
for pkg in self.upgrade_all:
check_md5(pkg_checksum(pkg, "slack_patches"), self.patch_path + pkg)
pkg_ver = "{0}-{1}".format(split_package(pkg)[0],
split_package(pkg)[1])
if find_package(split_package(pkg)[0] + self.meta.sp,
self.meta.pkg_path):
print("[ {0}upgrading{1} ] --> {2}".format(
self.meta.color["YELLOW"], self.meta.color["ENDC"],
pkg[:-4]))
PackageManager((self.patch_path + pkg).split()).upgrade(
"--install-new")
self.upgraded.append(pkg_ver)
else:
print("[ {0}installing{1} ] --> {2}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"],
pkg[:-4]))
PackageManager((self.patch_path + pkg).split()).upgrade(
"--install-new")
self.installed.append(pkg_ver)
def kernel(self):
"""
Check if kernel upgraded if true
then reinstall "lilo"
"""
for core in self.upgrade_all:
if "kernel" in core:
if self.meta.default_answer in ["y", "Y"]:
answer = self.meta.default_answer
else:
print("")
self.msg.template(78)
print("| {0}*** HIGHLY recommended reinstall 'LILO' "
"***{1}".format(self.meta.color["RED"],
self.meta.color["ENDC"]))
self.msg.template(78)
try:
answer = raw_input("\nThe kernel has been upgraded, "
"reinstall `LILO` [y/N]? ")
except EOFError:
print("")
raise SystemExit()
if answer in ["y", "Y"]:
subprocess.call("lilo", shell=True)
break
def slackpkg_update(self):
"""This replace slackpkg ChangeLog.txt file with new
from Slackware official mirrors after update distribution.
"""
NEW_ChangeLog_txt = URL(mirrors("ChangeLog.txt", "")).reading()
if os.path.isfile(self.meta.slackpkg_lib_path + "ChangeLog.txt.old"):
os.remove(self.meta.slackpkg_lib_path + "ChangeLog.txt.old")
if os.path.isfile(self.meta.slackpkg_lib_path + "ChangeLog.txt"):
shutil.copy2(self.meta.slackpkg_lib_path + "ChangeLog.txt",
self.meta.slackpkg_lib_path + "ChangeLog.txt.old")
os.remove(self.meta.slackpkg_lib_path + "ChangeLog.txt")
with open(self.meta.slackpkg_lib_path + "ChangeLog.txt", "w") as log:
log.write(NEW_ChangeLog_txt)
log.close()
def update_lists(self):
"""Update packages list and ChangeLog.txt file after
upgrade distribution
"""
print("{0}Update package lists ?{1}".format(self.meta.color["GREEN"],
self.meta.color["ENDC"]))
print("=" * 79)
if self.msg.answer() in ["y", "Y"]:
Update().repository(["slack"])
class Updates(object):
"""Checking for news in ChangeLog.txt
"""
def __init__(self, repo):
self.repo = repo
self.meta = _meta_
self.msg = Msg()
self.check = 2
self.st = ""
self.count_repo = 0
self.count_news = 0
self._init = Initialization(True)
self.all_repos = {
"slack": self._init.slack,
"sbo": self._init.sbo,
"rlw": self._init.rlw,
"alien": self._init.alien,
"slacky": self._init.slacky,
"conrad": self._init.conrad,
"slonly": self._init.slonly,
"ktown": self._init.ktown,
"multi": self._init.multi,
"slacke": self._init.slacke,
"salix": self._init.salix,
"slackl": self._init.slackl,
"rested": self._init.rested,
"msb": self._init.msb,
"csb": self._init.csb,
"connos": self._init.msb,
"mles": self._init.mles
}
def status_bar(self):
"""Top view bar status
"""
print("")
self.msg.template(78)
print("| Repository Status")
self.msg.template(78)
def run(self):
"""Run and check if new in ChangeLog.txt
"""
if (self.repo in self.meta.default_repositories
and self.repo in self.meta.repositories):
try:
self.check = self.all_repos[self.repo]()
except OSError:
usage(self.repo)
raise SystemExit()
elif self.repo in self.meta.repositories:
self.check = self._init.custom(self.repo)
else:
usage(self.repo)
raise SystemExit()
self.status_bar()
self.status()
self.print_status(self.repo)
self.summary()
def ALL(self):
"""Check ALL enabled repositories ChangeLogs
"""
self.status_bar()
for repo in self.meta.repositories:
if repo in self.meta.default_repositories:
try:
self.check = self.all_repos[repo]()
except OSError:
usage(self.repo)
raise SystemExit()
elif repo in self.meta.repositories:
self.check = self._init.custom(repo)
self.status()
self.print_status(repo)
self.summary()
def status(self):
"""Set messages
"""
self.count_repo += 1
if self.check == 1:
self.count_news += 1
self.st = "{0}News in ChangeLog.txt{1}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"])
elif self.check == 0:
self.st = "No changes in ChangeLog.txt"
def print_status(self, repo):
"""Print status
"""
print(" {0}{1}{2}".format(repo, " " * (19 - len(repo)), self.st))
def summary(self):
"""Print summary
"""
print("\nSummary")
print("=" * 79)
cmd = "All repositories are updated."
if self.count_repo == 1:
cmd = "Repository is updated."
if self.count_news > 0:
cmd = "Run the command 'slpkg update'."
print("{0}From {1} repositories need {2} updating. {3}{4}\n".format(
self.meta.color["GREY"], self.count_repo, self.count_news, cmd,
self.meta.color["ENDC"]))
class Patches(object):
"""Upgrade distribution from official Slackware mirrors
"""
def __init__(self, skip, flag):
self.skip = skip
self.flag = flag
self.meta = _meta_
self.msg = Msg()
self.version = self.meta.slack_rel
self.patch_path = self.meta.slpkg_tmp_patches
self.pkg_for_upgrade = []
self.dwn_links = []
self.upgrade_all = []
self.count_added = 0
self.count_upg = 0
self.upgraded = []
self.installed = []
self.comp_sum = []
self.uncomp_sum = []
self.utils = Utils()
self.msg.checking()
if self.version == "stable":
self.PACKAGES_TXT = URL(mirrors("PACKAGES.TXT",
"patches/")).reading()
else:
self.PACKAGES_TXT = URL(mirrors("PACKAGES.TXT", "")).reading()
def start(self):
"""
Install new patches from official Slackware mirrors
"""
self.store()
self.msg.done()
if self.upgrade_all:
if "--checklist" in self.flag:
self.dialog_checklist()
print("\nThese packages need upgrading:\n")
self.msg.template(78)
print("{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}".format(
"| Package", " " * 17, "New Version", " " * 8, "Arch", " " * 4,
"Build", " " * 2, "Repos", " " * 10, "Size"))
self.msg.template(78)
print("Upgrading:")
self.views()
unit, size = units(self.comp_sum, self.uncomp_sum)
print("\nInstalling summary")
print("=" * 79)
print("{0}Total {1} {2} will be upgraded and {3} will be "
"installed.".format(self.meta.color["GREY"], self.count_upg,
self.msg.pkg(self.upgrade_all),
self.count_added))
print("Need to get {0} {1} of archives.".format(size[0], unit[0]))
print("After this process, {0} {1} of additional disk space "
"will be used.{2}".format(size[1], unit[1],
self.meta.color["ENDC"]))
print("")
if self.msg.answer() in ["y", "Y"]:
Download(self.patch_path, self.dwn_links, repo="slack").start()
self.upgrade_all = self.utils.check_downloaded(
self.patch_path, self.upgrade_all)
self.upgrade()
self.kernel()
if self.meta.slackpkg_log in ["on", "ON"]:
self.slackpkg_update()
self.msg.reference(self.installed, self.upgraded)
delete_package(self.patch_path, self.upgrade_all)
self.update_lists()
else:
slack_arch = ""
if self.meta.arch == "x86_64":
slack_arch = "64"
print("\nSlackware{0} '{1}' v{2} distribution is up to "
"date\n".format(slack_arch, self.version, slack_ver()))
def store(self):
"""
Store and return packages for upgrading
"""
data = repo_data(self.PACKAGES_TXT, "slack", self.flag)
black = BlackList().packages(pkgs=data[0], repo="slack")
for name, loc, comp, uncomp in zip(data[0], data[1], data[2], data[3]):
status(0.0003)
repo_pkg_name = split_package(name)[0]
if (not os.path.isfile(self.meta.pkg_path + name[:-4])
and repo_pkg_name not in black
and repo_pkg_name not in self.skip):
self.dwn_links.append("{0}{1}/{2}".format(
mirrors("", ""), loc, name))
self.comp_sum.append(comp)
self.uncomp_sum.append(uncomp)
self.upgrade_all.append(name)
self.count_upg += 1
if not find_package(repo_pkg_name + self.meta.sp,
self.meta.pkg_path):
self.count_added += 1
self.count_upg -= 1
return self.count_upg
def dialog_checklist(self):
"""Create checklist to choose packages for upgrade
"""
data = []
for upg in self.upgrade_all:
data.append(upg[:-4])
text = "Press 'spacebar' to unchoose packages from upgrade"
title = " Upgrade "
backtitle = "{0} {1}".format(self.meta.__all__, self.meta.__version__)
status = True
pkgs = DialogUtil(data, text, title, backtitle, status).checklist()
index = 0
for pkg, comp, uncomp in zip(self.upgrade_all, self.comp_sum,
self.uncomp_sum):
if pkg[:-4] not in pkgs:
self.dwn_links.pop(index)
self.upgrade_all.pop(index)
self.comp_sum.pop(index)
self.uncomp_sum.pop(index)
self.count_upg -= 1
del comp, uncomp
index -= 1
index += 1
if not self.upgrade_all:
raise SystemExit()
def views(self):
"""
Views packages
"""
for upg, size in sorted(zip(self.upgrade_all, self.comp_sum)):
pkg_repo = split_package(upg[:-4])
color = self.meta.color["RED"]
pkg_inst = GetFromInstalled(pkg_repo[0]).name()
if pkg_repo[0] == pkg_inst:
color = self.meta.color["YELLOW"]
ver = GetFromInstalled(pkg_repo[0]).version()
print(" {0}{1}{2}{3} {4}{5} {6}{7}{8}{9}{10}{11:>12}{12}".format(
color, pkg_repo[0] + ver, self.meta.color["ENDC"],
" " * (23 - len(pkg_repo[0] + ver)), pkg_repo[1],
" " * (18 - len(pkg_repo[1])), pkg_repo[2],
" " * (8 - len(pkg_repo[2])), pkg_repo[3],
" " * (7 - len(pkg_repo[3])), "Slack", size, " K")).rstrip()
def upgrade(self):
"""
Upgrade packages
"""
for pkg in self.upgrade_all:
check_md5(pkg_checksum(pkg, "slack_patches"),
self.patch_path + pkg)
pkg_ver = "{0}-{1}".format(
split_package(pkg)[0],
split_package(pkg)[1])
if find_package(
split_package(pkg)[0] + self.meta.sp, self.meta.pkg_path):
print("[ {0}upgrading{1} ] --> {2}".format(
self.meta.color["YELLOW"], self.meta.color["ENDC"],
pkg[:-4]))
PackageManager(
(self.patch_path + pkg).split()).upgrade("--install-new")
self.upgraded.append(pkg_ver)
else:
print("[ {0}installing{1} ] --> {2}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"],
pkg[:-4]))
PackageManager(
(self.patch_path + pkg).split()).upgrade("--install-new")
self.installed.append(pkg_ver)
def kernel(self):
"""
Check if kernel upgraded if true
then reinstall "lilo"
"""
for core in self.upgrade_all:
if "kernel" in core:
if self.meta.default_answer in ["y", "Y"]:
answer = self.meta.default_answer
else:
print("")
self.msg.template(78)
print("| {0}*** HIGHLY recommended reinstall 'LILO' "
"***{1}".format(self.meta.color["RED"],
self.meta.color["ENDC"]))
self.msg.template(78)
try:
answer = raw_input("\nThe kernel has been upgraded, "
"reinstall `LILO` [y/N]? ")
except EOFError:
print("")
raise SystemExit()
if answer in ["y", "Y"]:
subprocess.call("lilo", shell=True)
break
def slackpkg_update(self):
"""This replace slackpkg ChangeLog.txt file with new
from Slackware official mirrors after update distribution.
"""
NEW_ChangeLog_txt = URL(mirrors("ChangeLog.txt", "")).reading()
if os.path.isfile(self.meta.slackpkg_lib_path + "ChangeLog.txt.old"):
os.remove(self.meta.slackpkg_lib_path + "ChangeLog.txt.old")
if os.path.isfile(self.meta.slackpkg_lib_path + "ChangeLog.txt"):
shutil.copy2(self.meta.slackpkg_lib_path + "ChangeLog.txt",
self.meta.slackpkg_lib_path + "ChangeLog.txt.old")
os.remove(self.meta.slackpkg_lib_path + "ChangeLog.txt")
with open(self.meta.slackpkg_lib_path + "ChangeLog.txt", "w") as log:
log.write(NEW_ChangeLog_txt)
log.close()
def update_lists(self):
"""Update packages list and ChangeLog.txt file after
upgrade distribution
"""
print("{0}Update the package lists ?{1}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"]))
print("=" * 79)
if self.msg.answer() in ["y", "Y"]:
Update().repository(["slack"])
class Updates(object):
"""Checking for news in ChangeLog.txt
"""
def __init__(self, repo):
self.repo = repo
self.meta = _meta_
self.msg = Msg()
self.check = 2
self.st = ""
self.count_repo = 0
self.count_news = 0
self._init = Initialization(True)
self.all_repos = {
"slack": self._init.slack,
"sbo": self._init.sbo,
"rlw": self._init.rlw,
"alien": self._init.alien,
"slacky": self._init.slacky,
"studio": self._init.studio,
"slackr": self._init.slackr,
"slonly": self._init.slonly,
"ktown": self._init.ktown,
"multi": self._init.multi,
"slacke": self._init.slacke,
"salix": self._init.salix,
"slackl": self._init.slackl,
"rested": self._init.rested,
"msb": self._init.msb
}
def status_bar(self):
"""Top view bar status
"""
print("")
self.msg.template(78)
print("| Repository Status")
self.msg.template(78)
def run(self):
"""Run and check if new in ChangeLog.txt
"""
if (self.repo in self.meta.default_repositories and
self.repo in self.meta.repositories):
try:
self.check = self.all_repos[self.repo]()
except OSError:
usage(self.repo)
raise SystemExit()
elif self.repo in self.meta.repositories:
self.check = self._init.custom(self.repo)
else:
usage(self.repo)
raise SystemExit()
self.status_bar()
self.status()
self.print_status(self.repo)
self.summary()
def ALL(self):
"""Check ALL enabled repositories ChangeLogs
"""
self.status_bar()
for repo in self.meta.repositories:
if repo in self.meta.default_repositories:
try:
self.check = self.all_repos[repo]()
except OSError:
usage(self.repo)
raise SystemExit()
elif repo in self.meta.repositories:
self.check = self._init.custom(repo)
self.status()
self.print_status(repo)
self.summary()
def status(self):
"""Set messages
"""
self.count_repo += 1
if self.check == 1:
self.count_news += 1
self.st = "{0}News in ChangeLog.txt{1}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"])
elif self.check == 0:
self.st = "No changes in ChangeLog.txt"
def print_status(self, repo):
"""Print status
"""
print(" {0}{1}{2}".format(repo, " " * (19 - len(repo)), self.st))
def summary(self):
"""Print summary
"""
print("\nSummary")
print("=" * 79)
cmd = "All repositories are updated."
if self.count_repo == 1:
cmd = "Repository is updated."
if self.count_news > 0:
cmd = "Run the command 'slpkg update'."
print("{0}From {1} repositories need {2} updating. {3}{4}\n".format(
self.meta.color["GREY"], self.count_repo, self.count_news, cmd,
self.meta.color["ENDC"]))
class NewConfig(object):
"""Manage .new configuration files
"""
def __init__(self):
self.meta = _meta_
self.msg = Msg()
self.red = self.meta.color["RED"]
self.green = self.meta.color["GREEN"]
self.endc = self.meta.color["ENDC"]
self.br = ""
if self.meta.use_colors in ["off", "OFF"]:
self.br = ")"
self.etc = "/etc/"
self.news = []
def run(self):
"""print .new configuration files
"""
self.find_new()
for n in self.news:
print("{0}".format(n))
print("")
self.msg.template(78)
print("| Installed {0} new configuration files:".format(len(self.news)))
self.msg.template(78)
self.choices()
def find_new(self):
"""Find all '.new' files from /etc/ folder
and subfolders
"""
print("\nSearch for .new configuration files:\n")
for path, dirs, files in os.walk(self.etc):
del dirs # delete unsed
for f in files:
if f.endswith(".new"):
self.news.append(os.path.join(path, f))
if not self.news:
print(" No new configuration files\n")
raise SystemExit()
def choices(self):
"""Menu options for new configuration files
"""
print("| {0}K{1}{2}eep the old and .new files, no changes".format(self.red, self.endc, self.br))
print("| {0}O{1}{2}verwrite all old configuration files with new " "ones".format(self.red, self.endc, self.br))
print("| The old files will be saved with suffix .old")
print("| {0}R{1}{2}emove all .new files".format(self.red, self.endc, self.br))
print("| {0}P{1}{2}rompt K, O, R, D, M option for each single " "file".format(self.red, self.endc, self.br))
print("| {0}Q{1}{2}uit from menu".format(self.red, self.endc, self.br))
self.msg.template(78)
try:
choose = raw_input("\nWhat would you like to do [K/O/R/P/Q]? ")
except EOFError:
print("")
raise SystemExit()
print("")
if choose in ("K", "k"):
self.keep()
elif choose in ("O", "o"):
self.overwrite_all()
elif choose in ("R", "r"):
self.remove_all()
elif choose in ("P", "p"):
self.prompt()
def overwrite_all(self):
"""Overwrite all .new files and keep
old with suffix .old
"""
for n in self.news:
self._overwrite(n)
def remove_all(self):
"""Remove all .new files
"""
for n in self.news:
self._remove(n)
print("")
def prompt(self):
"""Select file
"""
self.msg.template(78)
print("| Choose what to do file by file:")
print(
"| {0}K{1}{2}eep, {3}O{4}{5}verwrite, {6}R{7}{8}emove, "
"{9}D{10}{11}iff, {12}M{13}{14}erge, {15}Q{16}{17}uit".format(
self.red,
self.endc,
self.br,
self.red,
self.endc,
self.br,
self.red,
self.endc,
self.br,
self.red,
self.endc,
self.br,
self.red,
self.endc,
self.br,
self.red,
self.endc,
self.br,
)
)
self.msg.template(78)
print("")
self.i = 0
try:
while self.i < len(self.news):
self.question(self.news[self.i])
self.i += 1
except EOFError:
print("")
raise SystemExit()
def question(self, n):
"""Choose what do to file by file
"""
print("")
prompt_ask = raw_input("{0} [K/O/R/D/M/Q]? ".format(n))
print("")
if prompt_ask in ("K", "k"):
self.keep()
elif prompt_ask in ("O", "o"):
self._overwrite(n)
elif prompt_ask in ("R", "r"):
self._remove(n)
elif prompt_ask in ("D", "d"):
self.diff(n)
self.i -= 1
elif prompt_ask in ("M", "m"):
self.merge(n)
elif prompt_ask in ("Q", "q", "quit"):
self.quit()
def _remove(self, n):
"""Remove one single file
"""
if os.path.isfile(n):
os.remove(n)
if not os.path.isfile(n):
print("File '{0}' removed".format(n))
def _overwrite(self, n):
"""Overwrite old file with new and keep file with suffix .old
"""
if os.path.isfile(n[:-4]):
shutil.copy2(n[:-4], n[:-4] + ".old")
print("Old file {0} saved as {1}.old".format(n[:-4].split("/")[-1], n[:-4].split("/")[-1]))
if os.path.isfile(n):
shutil.move(n, n[:-4])
print("New file {0} overwrite as {1}".format(n.split("/")[-1], n[:-4].split("/")[-1]))
def keep(self):
pass
def diff(self, n):
"""Print the differences between the two files
"""
if os.path.isfile(n[:-4]):
diff1 = Utils().read_file(n[:-4]).splitlines()
if os.path.isfile(n):
diff2 = Utils().read_file(n).splitlines()
lines, l, c = [], 0, 0
for a, b in itertools.izip_longest(diff1, diff2):
l += 1
if a != b:
for s1, s2 in itertools.izip_longest(str(a), str(b)):
c += 1
if s1 != s2:
break
print("@@ -{0},{1} +{2},{3} @@\n".format(l, c, l, c))
for line in lines[-3:]:
print("{0}".format(line))
if a is None:
a = ""
print("{0}{1}{2}{3}".format(self.red, "-", self.endc, a))
if b is None:
b = ""
print("{0}{1}{2}{3}".format(self.green, "+", self.endc, b))
lines = []
c = 0
else:
lines.append(a)
def merge(self, n):
"""Merge new file into old
"""
if os.path.isfile(n[:-4]):
old = Utils().read_file(n[:-4]).splitlines()
if os.path.isfile(n):
new = Utils().read_file(n).splitlines()
with open(n[:-4], "w") as out:
for l1, l2 in itertools.izip_longest(old, new):
if l1 is None:
l1 = ""
if l2 is None:
l2 = ""
if l1 != l2:
out.write(l2 + "\n")
else:
out.write(l1 + "\n")
print("The file {0} merged in file {1}".format(n.split("/")[-1], n[:-4].split("/")[-1]))
def quit(self):
raise SystemExit()
class SBoInstall(object):
"""Build and install SBo packages with all dependencies
"""
def __init__(self, slackbuilds, flag):
self.slackbuilds = slackbuilds
self.flag = flag
self.meta = _meta_
self.msg = Msg()
self.arch = SBoArch().get()
self.build_folder = self.meta.build_path
for fl in self.flag:
if fl.startswith("--directory-prefix="):
self.build_folder = fl.split("=")[1]
if not self.build_folder.endswith("/"):
self.build_folder += "/"
self.unst = ["UNSUPPORTED", "UNTESTED"]
self.master_packages = []
self.deps = []
self.dependencies = []
self.package_not_found = []
self.package_found = []
self.deps_dict = {}
self.answer = ""
self.match = False
self.count_ins = 0
self.count_upg = 0
self.count_uni = 0
self.msg.reading()
self.data = SBoGrep(name="").names()
self.blacklist = BlackList().packages(pkgs=self.data, repo="sbo")
def start(self, if_upgrade):
"""Start view, build and install SBo packages
"""
tagc = ""
self.if_upgrade = if_upgrade
self.case_insensitive()
for _sbo in self.slackbuilds:
status(0.03)
if _sbo in self.data and _sbo not in self.blacklist:
sbo_deps = Requires(self.flag).sbo(_sbo)
self.deps += sbo_deps
self.deps_dict[_sbo] = self.one_for_all(sbo_deps)
self.package_found.append(_sbo)
else:
self.package_not_found.append(_sbo)
self.update_deps()
if not self.package_found:
self.match = True
self.matching()
self.master_packages, mas_src = self.sbo_version_source(
self.package_found)
self.msg.done()
if (self.meta.rsl_deps in ["on", "ON"] and
self.flag != "--resolve-off" and not self.match):
self.msg.resolving()
self.dependencies, dep_src = self.sbo_version_source(
self.one_for_all(self.deps))
if (self.meta.rsl_deps in ["on", "ON"] and
self.flag != "--resolve-off" and not self.match):
self.msg.done()
self.clear_masters()
if self.package_found:
print("\nThe following packages will be automatically "
"installed or upgraded \nwith new version:\n")
self.top_view()
self.msg.upg_inst(self.if_upgrade)
# view master packages
for sbo, arch in zip(self.master_packages, mas_src):
tagc = self.tag(sbo)
name = "-".join(sbo.split("-")[:-1])
self.view_packages(tagc, name, sbo.split("-")[-1],
self.select_arch(arch))
self.view_installing_for_deps()
# view dependencies
for dep, arch in zip(self.dependencies, dep_src):
tagc = self.tag(dep)
name = "-".join(dep.split("-")[:-1])
self.view_packages(tagc, name, dep.split("-")[-1],
self.select_arch(arch))
count_total = sum([self.count_ins, self.count_upg,
self.count_uni])
print("\nInstalling summary")
print("=" * 79)
print("{0}Total {1} {2}.".format(
self.meta.color["GREY"], count_total,
self.msg.pkg(count_total)))
print("{0} {1} will be installed, {2} already installed and "
"{3} {4}".format(self.count_uni,
self.msg.pkg(self.count_uni),
self.count_ins, self.count_upg,
self.msg.pkg(self.count_upg)))
print("will be upgraded.{0}\n".format(self.meta.color["ENDC"]))
self.continue_to_install()
else:
self.msg.not_found(self.if_upgrade)
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 name in self.slackbuilds:
index = self.slackbuilds.index(name)
for key, value in data_dict.iteritems():
if key == name.lower():
self.slackbuilds[index] = value
def update_deps(self):
"""Update dependencies dictionary with all package
"""
onelist, dependencies = [], []
onelist = Utils().dimensional_list(self.deps)
dependencies = Utils().remove_dbs(onelist)
for dep in dependencies:
deps = Requires(self.flag).sbo(dep)
self.deps_dict[dep] = self.one_for_all(deps)
def continue_to_install(self):
"""Continue to install ?
"""
if (self.count_uni > 0 or self.count_upg > 0 or
"--download-only" in self.flag):
if self.master_packages and self.msg.answer() in ["y", "Y"]:
installs, upgraded = self.build_install()
if "--download-only" in self.flag:
raise SystemExit()
self.msg.reference(installs, upgraded)
write_deps(self.deps_dict)
delete(self.build_folder)
def view_installing_for_deps(self):
"""View installing message for dependencies
"""
if not self.match and self.dependencies:
print("Installing for dependencies:")
def clear_masters(self):
"""Clear master slackbuilds if already exist in dependencies
or if added to install two or more times
"""
self.master_packages = Utils().remove_dbs(self.master_packages)
for mas in self.master_packages:
if mas in self.dependencies:
self.master_packages.remove(mas)
def matching(self):
"""Return found matching SBo packages
"""
for sbo in self.package_not_found:
for pkg in self.data:
if sbo in pkg and pkg not in self.blacklist:
self.package_found.append(pkg)
def sbo_version_source(self, slackbuilds):
"""Create sbo name with version
"""
sbo_versions, sources = [], []
for sbo in slackbuilds:
status(0.02)
sbo_ver = "{0}-{1}".format(sbo, SBoGrep(sbo).version())
sbo_versions.append(sbo_ver)
sources.append(SBoGrep(sbo).source())
return [sbo_versions, sources]
def one_for_all(self, deps):
"""Because there are dependencies that depend on other
dependencies are created lists into other lists.
Thus creating this loop create one-dimensional list and
remove double packages from dependencies.
"""
requires, dependencies = [], []
deps.reverse()
# Inverting the list brings the
# dependencies in order to be installed.
requires = Utils().dimensional_list(deps)
dependencies = Utils().remove_dbs(requires)
return dependencies
def top_view(self):
"""View top template
"""
self.msg.template(78)
print("{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}".format(
"| Package", " " * 17,
"New version", " " * 8,
"Arch", " " * 4,
"Build", " " * 2,
"Repos", " " * 10,
"Size"))
self.msg.template(78)
def view_packages(self, *args):
""":View slackbuild packages with version and arch
args[0] package color
args[1] package
args[2] version
args[3] arch
"""
ver = GetFromInstalled(args[1]).version()
print(" {0}{1}{2}{3} {4}{5} {6}{7}{8}{9}{10}{11:>11}{12}".format(
args[0], args[1] + ver, self.meta.color["ENDC"],
" " * (23-len(args[1] + ver)), args[2],
" " * (18-len(args[2])), args[3],
" " * (15-len(args[3])), "",
"", "SBo", "", "")).rstrip()
def tag(self, sbo):
"""Tag with color green if package already installed,
color yellow for packages to upgrade and color red
if not installed.
"""
# split sbo name with version and get name
sbo_name = "-".join(sbo.split("-")[:-1])
find = GetFromInstalled(sbo_name).name()
if find_package(sbo, self.meta.pkg_path):
paint = self.meta.color["GREEN"]
self.count_ins += 1
elif sbo_name == find:
paint = self.meta.color["YELLOW"]
self.count_upg += 1
else:
paint = self.meta.color["RED"]
self.count_uni += 1
return paint
def select_arch(self, src):
"""Looks if sources unsupported or untested
from arch else select arch.
"""
arch = self.arch
for item in self.unst:
if item in src:
arch = item
return arch
def filenames(self, sources):
"""Return filenames from sources links
"""
filename = []
for src in sources:
filename.append(src.split("/")[-1])
return filename
def build_install(self):
"""Build and install packages if not already installed
"""
slackbuilds = self.dependencies + self.master_packages
installs, upgraded, = [], []
if not os.path.exists(self.build_folder):
os.makedirs(self.build_folder)
os.chdir(self.build_folder)
for prgnam in slackbuilds:
pkg = "-".join(prgnam.split("-")[:-1])
installed = "".join(find_package(prgnam, self.meta.pkg_path))
src_link = SBoGrep(pkg).source().split()
if installed and "--download-only" not in self.flag:
self.msg.template(78)
self.msg.pkg_found(prgnam)
self.msg.template(78)
elif self.unst[0] in src_link or self.unst[1] in src_link:
self.msg.template(78)
print("| Package {0} {1}{2}{3}".format(
prgnam, self.meta.color["RED"], "".join(src_link),
self.meta.color["ENDC"]))
self.msg.template(78)
else:
sbo_url = sbo_search_pkg(pkg)
sbo_link = SBoLink(sbo_url).tar_gz()
script = sbo_link.split("/")[-1]
dwn_srcs = sbo_link.split() + src_link
Download(self.build_folder, dwn_srcs, repo="sbo").start()
if "--download-only" in self.flag:
continue
sources = self.filenames(src_link)
BuildPackage(script, sources, self.build_folder,
auto=False).build()
binary = slack_package(prgnam)
if GetFromInstalled(pkg).name() == pkg:
print("[ {0}Upgrading{1} ] --> {2}".format(
self.meta.color["YELLOW"],
self.meta.color["ENDC"], prgnam))
upgraded.append(prgnam)
else:
print("[ {0}Installing{1} ] --> {2}".format(
self.meta.color["GREEN"],
self.meta.color["ENDC"], prgnam))
installs.append(prgnam)
PackageManager(binary).upgrade(flag="--install-new")
return installs, upgraded
class PackageHealth(object):
"""Health check installed packages
"""
def __init__(self, mode):
self.mode = mode
self.meta = _meta_
self.msg = Msg()
self.pkg_path = _meta_.pkg_path
self.installed = []
self.cn = 0
def packages(self):
"""Get all installed packages from /var/log/packages/ path
"""
self.installed = find_package("", self.pkg_path)
def check(self, line, pkg):
line = line.replace("\n", "")
try:
if (not line.endswith("/") and
not line.endswith(".new") and
not line.startswith("dev/") and
not line.startswith("install/") and
"/incoming/" not in line):
if not os.path.isfile("/" + line):
self.cn += 1
print("Not installed: {0}/{1}{2} --> {3}".format(
self.meta.color["RED"], line, self.meta.color["ENDC"],
pkg))
elif not self.mode:
print(line)
except IOError:
print("")
raise SystemExit()
def test(self):
"""Get started test each package and read file list
"""
self.packages()
self.cf = 0
for pkg in self.installed:
if os.path.isfile(self.meta.pkg_path + pkg):
self.lf = 0
with open(self.pkg_path + pkg, "r") as fopen:
for line in fopen:
self.cf += 1 # count all files
self.lf += 1 # count each package files
if self.lf > 19:
self.check(line, pkg)
self.results()
def results(self):
"""Print results
"""
print("")
per = int(round((float(self.cf) / (self.cf + self.cn)) * 100))
if per > 90:
color = self.meta.color["GREEN"]
elif per < 90 and per > 60:
color = self.meta.color["YELLOW"]
elif per < 60:
color = self.meta.color["RED"]
health = "{0}{1}%{2}".format(color, str(per), self.meta.color["ENDC"])
self.msg.template(78)
print("| {0}{1}{2}{3}{4}".format(
"Total files", " " * 7, "Not installed", " " * 40, "Health"))
self.msg.template(78)
print("| {0}{1}{2}{3}{4:>4}".format(
self.cf, " " * (18-len(str(self.cf))),
self.cn, " " * (55-len(str(self.cn))),
health))
self.msg.template(78)
class NewConfig(object):
"""Manage .new configuration files
"""
def __init__(self):
self.meta = _meta_
self.msg = Msg()
self.red = self.meta.color["RED"]
self.green = self.meta.color["GREEN"]
self.endc = self.meta.color["ENDC"]
self.br = ""
if self.meta.use_colors in ["off", "OFF"]:
self.br = ")"
self.etc = "/etc/"
self.news = []
def run(self):
"""print .new configuration files
"""
self.find_new()
for n in self.news:
print("{0}".format(n))
print("")
self.msg.template(78)
print("| Installed {0} new configuration files:".format(len(
self.news)))
self.msg.template(78)
self.choices()
def find_new(self):
"""Find all '.new' files from /etc/ folder
and subfolders
"""
print("\nSearch for .new configuration files:\n")
for path, dirs, files in os.walk(self.etc):
del dirs # delete unsed
for f in files:
if f.endswith(".new"):
self.news.append(os.path.join(path, f))
if not self.news:
print(" No new configuration files\n")
raise SystemExit()
def choices(self):
"""Menu options for new configuration files
"""
print("| {0}K{1}{2}eep the old and .new files, no changes".format(
self.red, self.endc, self.br))
print("| {0}O{1}{2}verwrite all old configuration files with new "
"ones".format(self.red, self.endc, self.br))
print("| The old files will be saved with suffix .old")
print("| {0}R{1}{2}emove all .new files".format(
self.red, self.endc, self.br))
print("| {0}P{1}{2}rompt K, O, R, D, M option for each single "
"file".format(self.red, self.endc, self.br))
print("| {0}Q{1}{2}uit from menu".format(self.red, self.endc, self.br))
self.msg.template(78)
try:
choose = raw_input("\nWhat would you like to do [K/O/R/P/Q]? ")
except EOFError:
print("")
raise SystemExit()
print("")
if choose in ("K", "k"):
self.keep()
elif choose in ("O", "o"):
self.overwrite_all()
elif choose in ("R", "r"):
self.remove_all()
elif choose in ("P", "p"):
self.prompt()
def overwrite_all(self):
"""Overwrite all .new files and keep
old with suffix .old
"""
for n in self.news:
self._overwrite(n)
def remove_all(self):
"""Remove all .new files
"""
for n in self.news:
self._remove(n)
print("")
def prompt(self):
"""Select file
"""
self.msg.template(78)
print("| Choose what to do file by file:")
print("| {0}K{1}{2}eep, {3}O{4}{5}verwrite, {6}R{7}{8}emove, "
"{9}D{10}{11}iff, {12}M{13}{14}erge, {15}Q{16}{17}uit".format(
self.red, self.endc, self.br, self.red, self.endc, self.br,
self.red, self.endc, self.br, self.red, self.endc, self.br,
self.red, self.endc, self.br, self.red, self.endc, self.br))
self.msg.template(78)
print("")
self.i = 0
try:
while self.i < len(self.news):
self.question(self.news[self.i])
self.i += 1
except EOFError:
print("")
raise SystemExit()
def question(self, n):
"""Choose what do to file by file
"""
print("")
prompt_ask = raw_input("{0} [K/O/R/D/M/Q]? ".format(n))
print("")
if prompt_ask in ("K", "k"):
self.keep()
elif prompt_ask in ("O", "o"):
self._overwrite(n)
elif prompt_ask in ("R", "r"):
self._remove(n)
elif prompt_ask in ("D", "d"):
self.diff(n)
self.i -= 1
elif prompt_ask in ("M", "m"):
self.merge(n)
elif prompt_ask in ("Q", "q", "quit"):
self.quit()
def _remove(self, n):
"""Remove one single file
"""
if os.path.isfile(n):
os.remove(n)
if not os.path.isfile(n):
print("File '{0}' removed".format(n))
def _overwrite(self, n):
"""Overwrite old file with new and keep file with suffix .old
"""
if os.path.isfile(n[:-4]):
shutil.copy2(n[:-4], n[:-4] + ".old")
print("Old file {0} saved as {1}.old".format(
n[:-4].split("/")[-1], n[:-4].split("/")[-1]))
if os.path.isfile(n):
shutil.move(n, n[:-4])
print("New file {0} overwrite as {1}".format(
n.split("/")[-1], n[:-4].split("/")[-1]))
def keep(self):
pass
def diff(self, n):
"""Print the differences between the two files
"""
if os.path.isfile(n[:-4]):
diff1 = Utils().read_file(n[:-4]).splitlines()
if os.path.isfile(n):
diff2 = Utils().read_file(n).splitlines()
lines, l, c = [], 0, 0
for a, b in itertools.izip_longest(diff1, diff2):
l += 1
if a != b:
for s1, s2 in itertools.izip_longest(str(a), str(b)):
c += 1
if s1 != s2:
break
print("@@ -{0},{1} +{2},{3} @@\n".format(l, c, l, c))
for line in lines[-3:]:
print("{0}".format(line))
if a is None:
a = ""
print("{0}{1}{2}{3}".format(self.red, "-", self.endc, a))
if b is None:
b = ""
print("{0}{1}{2}{3}".format(self.green, "+", self.endc, b))
lines = []
c = 0
else:
lines.append(a)
def merge(self, n):
"""Merge new file into old
"""
if os.path.isfile(n[:-4]):
old = Utils().read_file(n[:-4]).splitlines()
if os.path.isfile(n):
new = Utils().read_file(n).splitlines()
with open(n[:-4], "w") as out:
for l1, l2 in itertools.izip_longest(old, new):
if l1 is None:
l1 = ""
if l2 is None:
l2 = ""
if l1 != l2:
out.write(l2 + "\n")
else:
out.write(l1 + "\n")
print("The file {0} merged in file {1}".format(
n.split("/")[-1], n[:-4].split("/")[-1]))
def quit(self):
raise SystemExit()
class Download(object):
"""Downloader manager. Slpkg use wget by default but support
curl, aria2 and http
"""
def __init__(self, path, url, repo):
self.path = path
self.url = url
self.repo = repo
self.file_name = ""
self.meta = _meta_
self.msg = Msg()
self.dir_prefix = ""
self.downder = self.meta.downder
self.downder_options = self.meta.downder_options
def start(self):
"""Download files using wget or other downloader.
Optional curl, aria2c and http
"""
dwn_count = 1
self._directory_prefix()
for dwn in self.url:
self.file_name = dwn.split("/")[-1]
self._check_certificate()
print("\n[{0}/{1}][ {2}Download{3} ] --> {4}\n".format(
dwn_count, len(self.url), self.meta.color["GREEN"],
self.meta.color["ENDC"],
self.file_name))
if self.downder in ["wget", "aria2c"]:
subprocess.call("{0} {1} {2}{3} {4}".format(
self.downder, self.downder_options,
self.dir_prefix, self.path, dwn),
shell=True)
elif self.downder in ["curl", "http"]:
subprocess.call("{0} {1} {2}{3} {4}".format(
self.downder, self.downder_options,
self.path, self.file_name, dwn), shell=True)
self._check_if_downloaded()
dwn_count += 1
def _directory_prefix(self):
"""Downloader options for specific directory
"""
if self.downder == "wget":
self.dir_prefix = "--directory-prefix="
elif self.downder == "aria2c":
self.dir_prefix = "--dir="
def _check_if_downloaded(self):
"""Check if file downloaded
"""
if not os.path.isfile(self.path + self.file_name):
print("")
self.msg.template(78)
print("| Download '{0}' file [ {1}FAILED{2} ]".format(
self.file_name, self.meta.color["RED"],
self.meta.color["ENDC"]))
self.msg.template(78)
print("")
if not self.msg.answer() in ["y", "Y"]:
raise SystemExit()
def _check_certificate(self):
"""Check for certificates options for wget
"""
if (self.file_name.startswith("jdk-") and self.repo == "sbo" and
self.downder == "wget"):
certificate = (' --no-check-certificate --header="Cookie: '
'oraclelicense=accept-securebackup-cookie"')
self.msg.template(78)
print("| '{0}' need to go ahead downloading".format(
certificate[:23].strip()))
self.msg.template(78)
print("")
self.downder_options += certificate
if not self.msg.answer() in ["y", "Y"]:
raise SystemExit()
class PackageHealth(object):
"""Health check installed packages
"""
def __init__(self, mode):
self.mode = mode
self.meta = _meta_
self.msg = Msg()
self.pkg_path = _meta_.pkg_path
self.installed = []
self.cn = 0
def packages(self):
"""Get all installed packages from /var/log/packages/ path
"""
self.installed = find_package("", self.pkg_path)
def check(self, line, pkg):
line = line.replace("\n", "")
try:
if (not line.endswith("/") and not line.endswith(".new")
and not line.startswith("dev/")
and not line.startswith("install/")
and "/incoming/" not in line):
if not os.path.isfile(r"/" + line):
self.cn += 1
print("Not installed: {0}/{1}{2} --> {3}".format(
self.meta.color["RED"], line, self.meta.color["ENDC"],
pkg))
elif not self.mode:
print(line)
except IOError:
print("")
raise SystemExit()
def test(self):
"""Get started test each package and read file list
"""
self.packages()
self.cf = 0
for pkg in self.installed:
if os.path.isfile(self.meta.pkg_path + pkg):
self.lf = 0
with open(self.pkg_path + pkg, "r") as fopen:
for line in fopen:
if "\0" in line:
print("Null: {0}").format(line)
break
self.cf += 1 # count all files
self.lf += 1 # count each package files
if self.lf > 19:
self.check(line, pkg)
self.results()
def results(self):
"""Print results
"""
print("")
per = int(round((float(self.cf) / (self.cf + self.cn)) * 100))
if per > 90:
color = self.meta.color["GREEN"]
elif per < 90 and per > 60:
color = self.meta.color["YELLOW"]
elif per < 60:
color = self.meta.color["RED"]
health = "{0}{1}%{2}".format(color, str(per), self.meta.color["ENDC"])
self.msg.template(78)
print("| {0}{1}{2}{3}{4}".format("Total files", " " * 7,
"Not installed", " " * 40, "Health"))
self.msg.template(78)
print("| {0}{1}{2}{3}{4:>4}".format(self.cf,
" " * (18 - len(str(self.cf))),
self.cn,
" " * (55 - len(str(self.cn))),
health))
self.msg.template(78)
class Download(object):
"""Downloader manager. Slpkg use wget by default but support
curl, aria2 and httpie
"""
def __init__(self, path, url, repo):
self.path = path
self.url = url
self.repo = repo
self.file_name = ""
self.meta = _meta_
self.msg = Msg()
self.dir_prefix = ""
self.downder = self.meta.downder
self.downder_options = self.meta.downder_options
def start(self):
"""Download files using wget or other downloader.
Optional curl, aria2c and httpie
"""
dwn_count = 1
self._directory_prefix()
for dwn in self.url:
# get file name from url and fix passing char '+'
self.file_name = dwn.split("/")[-1].replace("%2B", "+")
if dwn.startswith("file:///"):
source_dir = dwn[7:-7].replace(slack_ver(), "")
self._make_tarfile(self.file_name, source_dir)
self._check_certificate()
print("\n[{0}/{1}][ {2}Download{3} ] --> {4}\n".format(
dwn_count, len(self.url), self.meta.color["GREEN"],
self.meta.color["ENDC"], self.file_name))
if self.downder in ["wget", "aria2c"]:
subprocess.call("{0} {1} {2}{3} {4}".format(
self.downder, self.downder_options, self.dir_prefix,
self.path, dwn),
shell=True)
elif self.downder in ["curl", "http"]:
subprocess.call("{0} {1} {2}{3} {4}".format(
self.downder, self.downder_options, self.path,
self.file_name, dwn),
shell=True)
self._check_if_downloaded()
dwn_count += 1
def _make_tarfile(self, output_filename, source_dir):
"""Create .tar.gz file
"""
with tarfile.open(output_filename, "w:gz") as tar:
tar.add(source_dir, arcname=os.path.basename(source_dir))
def _directory_prefix(self):
"""Downloader options for specific directory
"""
if self.downder == "wget":
self.dir_prefix = "--directory-prefix="
elif self.downder == "aria2c":
self.dir_prefix = "--dir="
def _check_if_downloaded(self):
"""Check if file downloaded
"""
if not os.path.isfile(self.path + self.file_name):
print("")
self.msg.template(78)
print("| Download '{0}' file [ {1}FAILED{2} ]".format(
self.file_name, self.meta.color["RED"],
self.meta.color["ENDC"]))
self.msg.template(78)
print("")
if not self.msg.answer() in ["y", "Y"]:
raise SystemExit()
def _check_certificate(self):
"""Check for certificates options for wget
"""
if (self.file_name.startswith("jdk-") and self.repo == "sbo"
and self.downder == "wget"):
certificate = (' --no-check-certificate --header="Cookie: '
'oraclelicense=accept-securebackup-cookie"')
self.msg.template(78)
print("| '{0}' need to go ahead downloading".format(
certificate[:23].strip()))
self.msg.template(78)
print("")
self.downder_options += certificate
if not self.msg.answer() in ["y", "Y"]:
raise SystemExit()
class SBoInstall(object):
"""Build and install SBo packages with all dependencies
"""
def __init__(self, slackbuilds, flag):
self.slackbuilds = slackbuilds
pkg_security(self.slackbuilds)
self.flag = flag
self.meta = _meta_
self.msg = Msg()
self.arch = SBoArch().get()
self.build_folder = self.meta.build_path
self._SOURCES = self.meta.SBo_SOURCES
for fl in self.flag:
if fl.startswith("--directory-prefix="):
self.build_folder = fl.split("=")[1]
if not self.build_folder.endswith("/"):
self.build_folder += "/"
self.unst = ["UNSUPPORTED", "UNTESTED"]
self.master_packages = []
self.deps = []
self.dependencies = []
self.package_not_found = []
self.package_found = []
self.deps_dict = {}
self.answer = ""
self.match = False
self.count_ins = 0
self.count_upg = 0
self.count_uni = 0
self.msg.reading()
self.data = SBoGrep(name="").names()
self.blacklist = BlackList().packages(pkgs=self.data, repo="sbo")
def start(self, is_upgrade):
"""Start view, build and install SBo packages
"""
tagc = ""
self.is_upgrade = is_upgrade
self.case_insensitive()
for _sbo in self.slackbuilds:
status(0.03)
if _sbo in self.data and _sbo not in self.blacklist:
sbo_deps = Requires(self.flag).sbo(_sbo)
self.deps += sbo_deps
self.deps_dict[_sbo] = self.one_for_all(sbo_deps)
self.package_found.append(_sbo)
else:
self.package_not_found.append(_sbo)
self.update_deps()
if not self.package_found:
self.match = True
self.matching()
self.master_packages, mas_src = self.sbo_version_source(
self.package_found)
self.msg.done()
if (self.meta.rsl_deps in ["on", "ON"] and self.flag != "--resolve-off"
and not self.match):
self.msg.resolving()
self.dependencies, dep_src = self.sbo_version_source(
self.one_for_all(self.deps))
if (self.meta.rsl_deps in ["on", "ON"] and self.flag != "--resolve-off"
and not self.match):
self.msg.done()
self.clear_masters()
if self.package_found:
print("\nThe following packages will be automatically "
"installed or upgraded \nwith new version:\n")
self.top_view()
self.msg.upg_inst(self.is_upgrade)
# view master packages
for sbo, arch in zip(self.master_packages, mas_src):
tagc = self.tag(sbo)
name = "-".join(sbo.split("-")[:-1])
self.view_packages(tagc, name,
sbo.split("-")[-1], self.select_arch(arch))
self.view_installing_for_deps()
# view dependencies
for dep, arch in zip(self.dependencies, dep_src):
tagc = self.tag(dep)
name = "-".join(dep.split("-")[:-1])
self.view_packages(tagc, name,
dep.split("-")[-1], self.select_arch(arch))
count_total = sum([self.count_ins, self.count_upg, self.count_uni])
print("\nInstalling summary")
print("=" * 79)
print("{0}Total {1} {2}.".format(self.meta.color["GREY"],
count_total,
self.msg.pkg(count_total)))
print("{0} {1} will be installed, {2} already installed and "
"{3} {4}".format(self.count_uni,
self.msg.pkg(self.count_uni),
self.count_ins, self.count_upg,
self.msg.pkg(self.count_upg)))
print("will be upgraded.{0}\n".format(self.meta.color["ENDC"]))
self.continue_to_install()
else:
self.msg.not_found(self.is_upgrade)
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 name in self.slackbuilds:
index = self.slackbuilds.index(name)
for key, value in data_dict.iteritems():
if key == name.lower():
self.slackbuilds[index] = value
def update_deps(self):
"""Update dependencies dictionary with all package
"""
onelist, dependencies = [], []
onelist = Utils().dimensional_list(self.deps)
dependencies = Utils().remove_dbs(onelist)
for dep in dependencies:
deps = Requires(self.flag).sbo(dep)
self.deps_dict[dep] = self.one_for_all(deps)
def continue_to_install(self):
"""Continue to install ?
"""
if (self.count_uni > 0 or self.count_upg > 0
or "--download-only" in self.flag or "--rebuild" in self.flag):
if self.master_packages and self.msg.answer() in ["y", "Y"]:
installs, upgraded = self.build_install()
if "--download-only" in self.flag:
raise SystemExit()
self.msg.reference(installs, upgraded)
write_deps(self.deps_dict)
delete(self.build_folder)
def view_installing_for_deps(self):
"""View installing message for dependencies
"""
if not self.match and self.dependencies:
print("Installing for dependencies:")
def clear_masters(self):
"""Clear master slackbuilds if already exist in dependencies
or if added to install two or more times
"""
self.master_packages = Utils().remove_dbs(self.master_packages)
for mas in self.master_packages:
if mas in self.dependencies:
self.master_packages.remove(mas)
def matching(self):
"""Return found matching SBo packages
"""
for sbo in self.package_not_found:
for pkg in self.data:
if sbo in pkg and pkg not in self.blacklist:
self.package_found.append(pkg)
def sbo_version_source(self, slackbuilds):
"""Create sbo name with version
"""
sbo_versions, sources = [], []
for sbo in slackbuilds:
status(0.02)
sbo_ver = "{0}-{1}".format(sbo, SBoGrep(sbo).version())
sbo_versions.append(sbo_ver)
sources.append(SBoGrep(sbo).source())
return [sbo_versions, sources]
def one_for_all(self, deps):
"""Because there are dependencies that depend on other
dependencies are created lists into other lists.
Thus creating this loop create one-dimensional list and
remove double packages from dependencies.
"""
requires, dependencies = [], []
deps.reverse()
# Inverting the list brings the
# dependencies in order to be installed.
requires = Utils().dimensional_list(deps)
dependencies = Utils().remove_dbs(requires)
return dependencies
def top_view(self):
"""View top template
"""
self.msg.template(78)
print("{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}".format(
"| Package", " " * 17, "New version", " " * 8, "Arch", " " * 4,
"Build", " " * 2, "Repos", " " * 10, "Size"))
self.msg.template(78)
def view_packages(self, *args):
""":View slackbuild packages with version and arch
args[0] package color
args[1] package
args[2] version
args[3] arch
"""
ver = GetFromInstalled(args[1]).version()
print(" {0}{1}{2}{3} {4}{5} {6}{7}{8}{9}{10}{11:>11}{12}".format(
args[0], args[1] + ver, self.meta.color["ENDC"],
" " * (23 - len(args[1] + ver)), args[2],
" " * (18 - len(args[2])), args[3], " " * (15 - len(args[3])), "",
"", "SBo", "", "")).rstrip()
def tag(self, sbo):
"""Tag with color green if package already installed,
color yellow for packages to upgrade and color red
if not installed.
"""
# split sbo name with version and get name
sbo_name = "-".join(sbo.split("-")[:-1])
find = GetFromInstalled(sbo_name).name()
if find_package(sbo, self.meta.pkg_path):
paint = self.meta.color["GREEN"]
self.count_ins += 1
if "--rebuild" in self.flag:
self.count_upg += 1
elif sbo_name == find:
paint = self.meta.color["YELLOW"]
self.count_upg += 1
else:
paint = self.meta.color["RED"]
self.count_uni += 1
return paint
def select_arch(self, src):
"""Looks if sources unsupported or untested
from arch else select arch.
"""
arch = self.arch
for item in self.unst:
if item in src:
arch = item
return arch
def filenames(self, sources):
"""Return filenames from sources links
"""
filename = []
for src in sources:
filename.append(src.split("/")[-1])
return filename
def build_install(self):
"""Build and install packages if not already installed
"""
slackbuilds = self.dependencies + self.master_packages
installs, upgraded, = [], []
if not os.path.exists(self.build_folder):
os.makedirs(self.build_folder)
if not os.path.exists(self._SOURCES):
os.makedirs(self._SOURCES)
os.chdir(self.build_folder)
for prgnam in slackbuilds:
if (self.meta.not_downgrade == "on"
and self.not_downgrade(prgnam) is True):
continue
pkg = "-".join(prgnam.split("-")[:-1])
installed = "".join(find_package(prgnam, self.meta.pkg_path))
src_link = SBoGrep(pkg).source().split()
if (installed and "--download-only" not in self.flag
and "--rebuild" not in self.flag):
self.msg.template(78)
self.msg.pkg_found(prgnam)
self.msg.template(78)
elif self.unst[0] in src_link or self.unst[1] in src_link:
self.msg.template(78)
print("| Package {0} {1}{2}{3}".format(
prgnam, self.meta.color["RED"], "".join(src_link),
self.meta.color["ENDC"]))
self.msg.template(78)
else:
sbo_url = sbo_search_pkg(pkg)
sbo_link = SBoLink(sbo_url).tar_gz()
script = sbo_link.split("/")[-1]
if self.meta.sbosrcarch in ["on", "ON"]:
src_link = self.sbosrcarsh(prgnam, sbo_link, src_link)
Download(self.build_folder, sbo_link.split(),
repo="sbo").start()
Download(self._SOURCES, src_link, repo="sbo").start()
if "--download-only" in self.flag:
continue
sources = self.filenames(src_link)
BuildPackage(script, sources, self.build_folder,
auto=False).build()
binary = slack_package(prgnam)
if os.path.isfile("".join(binary)):
if GetFromInstalled(pkg).name() == pkg:
print("[ {0}Upgrading{1} ] --> {2}".format(
self.meta.color["YELLOW"], self.meta.color["ENDC"],
prgnam))
upgraded.append(prgnam)
else:
print("[ {0}Installing{1} ] --> {2}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"],
prgnam))
installs.append(prgnam)
if ("--rebuild" in self.flag
and GetFromInstalled(pkg).name() == pkg):
PackageManager(binary).upgrade(flag="--reinstall")
else:
PackageManager(binary).upgrade(flag="--install-new")
return installs, upgraded
def not_downgrade(self, prgnam):
"""Don't downgrade packages if sbo version is lower than
installed"""
name = "-".join(prgnam.split("-")[:-1])
sbo_ver = prgnam.split("-")[-1]
ins_ver = GetFromInstalled(name).version()[1:]
if not ins_ver:
ins_ver = "0"
if LooseVersion(sbo_ver) < LooseVersion(ins_ver):
self.msg.template(78)
print("| Package {0} don't downgrade, "
"setting by user".format(name))
self.msg.template(78)
return True
def sbosrcarsh(self, prgnam, sbo_link, src_link):
"""Alternative repository for sbo sources"""
sources = []
name = "-".join(prgnam.split("-")[:-1])
category = "{0}/{1}/".format(sbo_link.split("/")[-2], name)
for link in src_link:
source = link.split("/")[-1]
sources.append("{0}{1}{2}".format(self.meta.sbosrcarch_link,
category, source))
return sources
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 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")
