def store(*args):
'''
Store and return packages for upgrading
'''
(dwn, upgrade, comp_sum, uncomp_sum) = ([] for i in range(4))
if args[4] == "stable": # stables versions upgrade
for name, loc, comp, uncomp in zip(args[0], args[1], args[2], args[3]):
if (not os.path.isfile(pkg_path + name[:-4]) and split_package(
name)[0] not in BlackList().packages()):
dwn.append("{0}{1}/{2}".format(
mirrors("", "", args[4]), loc, name))
comp_sum.append(comp)
uncomp_sum.append(uncomp)
upgrade.append(name)
else: # current version upgrade
installed = []
# get all installed packages and store the package name.
for pkg in os.listdir(pkg_path):
installed.append(split_package(pkg)[0])
for name, loc, comp, uncomp in zip(args[0], args[1], args[2], args[3]):
# If the package from the current repository is installed
# (check with the name) but not is in the path (check with
# all package like 'apr-1.5.0-x86_64-1') then add to list for
# upgrade.
# etc. 'apr' in list 'installed' ?? if yes 'apr-1.5.0-x86_64-1'
# exist in /var/log/packages ?? if no add to upgrade.
if split_package(name)[0] in installed:
if (not os.path.isfile(pkg_path + name[:-4]) and
split_package(name)[0] not in BlackList().packages()):
dwn.append("{0}{1}/{2}".format(
mirrors("", "", args[4]), loc, name))
comp_sum.append(comp)
uncomp_sum.append(uncomp)
upgrade.append(name)
return [dwn, upgrade, comp_sum, uncomp_sum]
def pkg_upgrade(repo, skip, flag):
"""Checking packages for upgrade
"""
Msg().checking()
PACKAGES_TXT = RepoInit(repo).fetch()[0]
pkgs_for_upgrade = []
# name = data[0]
# location = data[1]
# size = data[2]
# unsize = data[3]
data = repo_data(PACKAGES_TXT, repo, flag="")
for pkg in installed():
status(0.0005)
inst_pkg = split_package(pkg)
for name in data[0]:
if name: # this tips because some pkg_name is empty
repo_pkg = split_package(name[:-4])
if (repo_pkg[0] == inst_pkg[0]
and LooseVersion(repo_pkg[1]) > LooseVersion(inst_pkg[1])
and repo_pkg[3] >= inst_pkg[3] and inst_pkg[0] not in skip
and repo_pkg[1] != "blacklist"):
pkgs_for_upgrade.append(repo_pkg[0])
Msg().done()
if "--checklist" in flag:
pkgs_for_upgrade = choose_upg(pkgs_for_upgrade)
return pkgs_for_upgrade
def store(*args):
'''
Store and return packages for upgrading
'''
(dwn, upgrade, comp_sum, uncomp_sum) = ([] for i in range(4))
if args[4] == "stable": # stables versions upgrade
for name, loc, comp, uncomp in zip(args[0], args[1], args[2], args[3]):
if (not os.path.isfile(pkg_path + name[:-4])
and split_package(name)[0] not in BlackList().packages()):
dwn.append("{0}{1}/{2}".format(mirrors("", "", args[4]), loc,
name))
comp_sum.append(comp)
uncomp_sum.append(uncomp)
upgrade.append(name)
else: # current version upgrade
installed = []
# get all installed packages and store the package name.
for pkg in os.listdir(pkg_path):
installed.append(split_package(pkg)[0])
for name, loc, comp, uncomp in zip(args[0], args[1], args[2], args[3]):
# If the package from the current repository is installed
# (check with the name) but not is in the path (check with
# all package like 'apr-1.5.0-x86_64-1') then add to list for
# upgrade.
# etc. 'apr' in list 'installed' ?? if yes 'apr-1.5.0-x86_64-1'
# exist in /var/log/packages ?? if no add to upgrade.
if split_package(name)[0] in installed:
if (not os.path.isfile(pkg_path + name[:-4]) and
split_package(name)[0] not in BlackList().packages()):
dwn.append("{0}{1}/{2}".format(mirrors("", "", args[4]),
loc, name))
comp_sum.append(comp)
uncomp_sum.append(uncomp)
upgrade.append(name)
return [dwn, upgrade, comp_sum, uncomp_sum]
def pkg_upgrade(repo, skip, flag):
"""
Checking packages for upgrade
"""
Msg().checking()
PACKAGES_TXT = RepoInit(repo).fetch()[0]
pkgs_for_upgrade = []
# name = data[0]
# location = data[1]
# size = data[2]
# unsize = data[3]
data = repo_data(PACKAGES_TXT, repo, flag="")
for pkg in installed():
status(0.0005)
inst_pkg = split_package(pkg)
for name in data[0]:
if name: # this tips because some pkg_name is empty
repo_pkg = split_package(name[:-4])
if (repo_pkg[0] == inst_pkg[0] and
LooseVersion(repo_pkg[1]) > LooseVersion(inst_pkg[1]) and
repo_pkg[3] >= inst_pkg[3] and
inst_pkg[0] not in skip and
repo_pkg[1] != "blacklist"):
pkgs_for_upgrade.append(repo_pkg[0])
Msg().done()
if "--checklist" in flag:
pkgs_for_upgrade = choose_upg(pkgs_for_upgrade)
return pkgs_for_upgrade
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 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 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]
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]
def pkg_upgrade(repo, skip):
"""
Checking packages for upgrade
"""
try:
Msg().checking()
PACKAGES_TXT = RepoInit(repo).fetch()[0]
pkgs_for_upgrade = []
# name = data[0]
# location = data[1]
# size = data[2]
# unsize = data[3]
data = repo_data(PACKAGES_TXT, repo, flag="")
for pkg in installed():
status(0.0005)
inst_pkg = split_package(pkg)
for name in data[0]:
if name: # this tips because some pkg_name is empty
repo_pkg = split_package(name[:-4])
if (
repo_pkg[0] == inst_pkg[0]
and LooseVersion(repo_pkg[1]) > LooseVersion(inst_pkg[1])
and repo_pkg[3] >= inst_pkg[3]
and inst_pkg[0] not in skip
):
pkgs_for_upgrade.append(repo_pkg[0])
Msg().done()
return pkgs_for_upgrade
except KeyboardInterrupt:
print("") # new line at exit
sys.exit(0)
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 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 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
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 __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 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 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 choose_upg(packages):
"""Create checklist to choose packages for upgrade
"""
selected_packages, data = [], []
if packages:
for pkg in packages:
name = GetFromInstalled(pkg).name()
ver = GetFromInstalled(pkg).version()
binary = "{0}{1}".format(name, ver)
installed = find_package(binary + _meta_.sp, _meta_.pkg_path)[0]
data.append(installed)
text = "Press 'spacebar' to unchoose packages from upgrade"
title = " Upgrade "
backtitle = "{0} {1}".format(_meta_.__all__, _meta_.__version__)
status = True
pkgs = DialogUtil(data, text, title, backtitle,
status).checklist()
pkgs = [] if pkgs is None else pkgs
for pkg in pkgs:
name = split_package(pkg)[0]
if name in packages:
selected_packages.append(name)
if not selected_packages:
raise SystemExit()
print("")
return selected_packages
def get_deps(self):
"""Grap package requirements from repositories
"""
if self.repo == "rlw":
# Robby"s repository dependencies as shown in the central page
# http://rlworkman.net/pkgs/
dependencies = {
"abiword": "wv",
"claws-mail": "libetpan",
"inkscape": "gtkmm atkmm pangomm cairomm mm-common libsigc++ "
"libwpg lxml gsl numpy BeautifulSoup",
"texlive": "libsigsegv texi2html",
"xfburn": "libburn libisofs"
}
if self.name in dependencies.keys():
return dependencies[self.name].split()
else:
return ""
else:
PACKAGES_TXT = Utils().read_file("{0}{1}_repo/PACKAGES.TXT".format(
_meta_.lib_path, self.repo))
for line in PACKAGES_TXT.splitlines():
if line.startswith("PACKAGE NAME:"):
pkg_name = split_package(line[14:].strip())[0]
if line.startswith("PACKAGE REQUIRED:"):
if pkg_name == self.name:
if line[18:].strip():
return self._req_fix(line)
def store(dependencies_list):
'''
In the end lest a check of the packages that are on the list
are already installed.
'''
(upgrade_name,
package_for_upgrade,
upgrade_version,
upgrade_arch
) = ([] for i in range(4))
for pkg in dependencies_list:
ver = SBoGrep(pkg).version()
prgnam = ("{0}-{1}".format(pkg, ver))
# if package not installed
# take version from repository
pkg_version = ver
arch = os.uname()[4]
if arch.startswith("i") and arch.endswith("86"):
arch = "i486"
if find_package(prgnam, pkg_path) == []:
for sbo in os.listdir(pkg_path):
if (sbo.startswith(pkg + sp) and
sbo.endswith("_SBo")):
# search if packages installed
# if yes grab package name and version
pkg_version = split_package(sbo)[1]
upgrade_name.append(pkg)
package_for_upgrade.append("{0}-{1}".format(pkg, pkg_version))
upgrade_version.append(ver)
upgrade_arch.append(arch)
return [upgrade_name, package_for_upgrade, upgrade_version, upgrade_arch]
def add(self, repo, pkg):
"""Split packages by repository
"""
if repo == "sbo":
return pkg
else:
return split_package(pkg)[0]
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 _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 = []
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 add(self, repo, pkg):
"""Split packages by repository
"""
if repo == "sbo":
return pkg
else:
return split_package(pkg)[0]
def choose_upg(packages):
"""Create checklist to choose packages for upgrade
"""
selected_packages, data = [], []
if packages:
for pkg in packages:
name = GetFromInstalled(pkg).name()
ver = GetFromInstalled(pkg).version()
binary = "{0}{1}".format(name, ver)
installed = find_package(binary + _meta_.sp, _meta_.pkg_path)[0]
data.append(installed)
text = "Press 'spacebar' to unchoose packages from upgrade"
title = " Upgrade "
backtitle = "{0} {1}".format(_meta_.__all__, _meta_.__version__)
status = True
pkgs = DialogUtil(data, text, title, backtitle, status).checklist()
pkgs = [] if pkgs is None else pkgs
for pkg in pkgs:
name = split_package(pkg)[0]
if name in packages:
selected_packages.append(name)
if not selected_packages:
raise SystemExit()
print("")
return selected_packages
def package_name(self, PACKAGES_TXT):
"""Returns list with all the names of packages repository
"""
packages = []
for line in PACKAGES_TXT.splitlines():
if line.startswith("PACKAGE NAME:"):
packages.append(split_package(line[14:].strip())[0])
return packages
def exists(index, toolbar_width):
'''
search packages if exists in the repository
and it gets to avoidable modified packages
from the user with the tag _SBo
'''
upgrade_names = []
for pkg in sbo_list():
index += 1
toolbar_width = status(index, toolbar_width, 4)
name = split_package(pkg)[0]
if sbo_search_pkg(name):
sbo_package = ("{0}-{1}".format(name, SBoGrep(name).version()))
package = ("{0}-{1}".format(name, split_package(pkg)[1]))
if sbo_package > package:
upgrade_names.append(name)
return upgrade_names
def package_name(self, PACKAGES_TXT):
"""Returns list with all the names of packages repository
"""
packages = []
for line in PACKAGES_TXT.splitlines():
if line.startswith("PACKAGE NAME:"):
packages.append(split_package(line[14:].strip())[0])
return packages
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 __init__(self, package):
self.package = package
self.meta = _meta_
self.files = find_package(self.package + self.meta.sp,
self.meta.pkg_path)
self.find = ""
for f in self.files:
if split_package(f)[0] == self.package:
self.find = f
def __init__(self, package):
self.package = package
self.meta = _meta_
self.files = find_package(self.package + self.meta.sp,
self.meta.pkg_path)
self.find = ""
for f in self.files:
if split_package(f)[0] == self.package:
self.find = f
def find_package(find_pkg, directory):
'''
Find packages
'''
pkgs = []
blacklist = BlackList().packages()
for pkg in sorted(os.listdir(directory)):
if pkg.startswith(find_pkg) and split_package(pkg)[0] not in blacklist:
pkgs.append(pkg)
return pkgs
def views(upgrade_all, comp_sum):
'''
Views packages
'''
for upgrade, size in zip(upgrade_all, comp_sum):
pkg_split = split_package(upgrade[:-4])
print(" {0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11:>12}{12}".format(
YELLOW, pkg_split[0], ENDC, " " * (25 - len(pkg_split[0])),
pkg_split[1], " " * (19 - len(pkg_split[1])), pkg_split[2],
" " * (8 - len(pkg_split[2])), pkg_split[3],
" " * (7 - len(pkg_split[3])), "Slack", size, " K"))
def sbo_upgrade(skip, flag):
"""Return packages for upgrade
"""
Msg().checking()
upgrade_names = []
data = SBoGrep(name="").names()
blacklist = BlackList().packages(pkgs=data, repo="sbo")
for pkg in sbo_list():
status(0.02)
name = split_package(pkg)[0]
ver = split_package(pkg)[1]
if (name in data and name not in skip and name not in blacklist):
sbo_package = ("{0}-{1}".format(name, SBoGrep(name).version()))
package = ("{0}-{1}".format(name, ver))
if LooseVersion(sbo_package) > LooseVersion(package):
upgrade_names.append(name)
Msg().done()
if "--checklist" in flag:
upgrade_names = choose_upg(upgrade_names)
return upgrade_names
def slack_package(prgnam):
"""Search for binary packages in output directory
"""
binary = ""
# Get build number from prgnam.SlackBuild script
build1 = BuildNumber("", "-".join(prgnam.split("-")[:-1])).get()
for pkg in find_package(prgnam + _meta_.sp, _meta_.output):
name = split_package(pkg[:-4])[0]
ver = split_package(pkg[:-4])[1]
prgnam_find = "{0}-{1}".format(name, ver)
# Get build number from binary package
build2 = split_package(pkg[:-4])[3]
if (pkg[:-4].endswith("_SBo") and prgnam_find == prgnam and
build1 == build2):
binary = pkg
break
if binary not in sbo_packages():
Msg().build_FAILED(prgnam)
raise SystemExit()
return ["".join(_meta_.output + binary)]
def sbo_upgrade(skip, flag):
"""Return packages for upgrade
"""
Msg().checking()
upgrade_names = []
data = SBoGrep(name="").names()
blacklist = BlackList().packages(pkgs=data, repo="sbo")
for pkg in sbo_list():
status(0.02)
name = split_package(pkg)[0]
ver = split_package(pkg)[1]
if (name in data and name not in skip and name not in blacklist):
sbo_package = ("{0}-{1}".format(name, SBoGrep(name).version()))
package = ("{0}-{1}".format(name, ver))
if LooseVersion(sbo_package) > LooseVersion(package):
upgrade_names.append(name)
Msg().done()
if "--checklist" in flag:
upgrade_names = choose_upg(upgrade_names)
return upgrade_names
def alien_filter(packages, sizes):
"""This filter avoid list double packages from
alien repository
"""
cache, npkg, nsize = [], [], []
for p, s in zip(packages, sizes):
name = split_package(p)[0]
if name not in cache:
cache.append(name)
npkg.append(p)
nsize.append(s)
return npkg, nsize
def alien_filter(packages, sizes):
"""This filter avoid list double packages from
alien repository
"""
cache, npkg, nsize = [], [], []
for p, s in zip(packages, sizes):
name = split_package(p)[0]
if name not in cache:
cache.append(name)
npkg.append(p)
nsize.append(s)
return npkg, nsize
def views(upgrade_all, comp_sum):
'''
Views packages
'''
for upgrade, size in zip(upgrade_all, comp_sum):
pkg_split = split_package(upgrade[:-4])
print(" {0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11:>12}{12}".format(
YELLOW, pkg_split[0], ENDC,
" " * (25-len(pkg_split[0])), pkg_split[1],
" " * (19-len(pkg_split[1])), pkg_split[2],
" " * (8-len(pkg_split[2])), pkg_split[3],
" " * (7-len(pkg_split[3])), "Slack",
size, " K"))
def find_package(find_pkg, directory):
"""Find packages
"""
pkgs = []
if os.path.isdir(directory):
installed = sorted(os.listdir(directory))
blacklist = BlackList().packages(pkgs=installed, repo="local")
if os.path.exists(directory):
for pkg in installed:
if (not pkg.startswith(".") and pkg.startswith(find_pkg) and
split_package(pkg)[0] not in blacklist):
pkgs.append(pkg)
return pkgs
def find_package(find_pkg, directory):
"""Find packages
"""
pkgs = []
if os.path.isdir(directory):
installed = sorted(os.listdir(directory))
blacklist = BlackList().packages(pkgs=installed, repo="local")
if os.path.exists(directory):
for pkg in installed:
if (not pkg.startswith(".") and pkg.startswith(find_pkg)
and split_package(pkg)[0] not in blacklist):
pkgs.append(pkg)
return pkgs
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.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 build_install(self):
"""Searches the package name and version in /tmp to
install. If find two or more packages e.g. to build
tag 2 or 3 will fit most.
"""
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 sbo in slackbuilds:
pkg = "-".join(sbo.split("-")[:-1])
ver = sbo.split("-")[-1]
prgnam = ("{0}-{1}".format(pkg, ver))
sbo_file = "".join(find_package(prgnam, self.meta.pkg_path))
src_link = SBoGrep(pkg).source().split()
if sbo_file:
Msg().template(78)
Msg().pkg_found(pkg, split_package(sbo_file)[1])
Msg().template(78)
elif self.unst[0] in src_link or self.unst[1] in src_link:
Msg().template(78)
print("| Package {0} {1}{2}{3}".format(
sbo, self.meta.color["RED"], "".join(src_link),
self.meta.color["ENDC"]))
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()
sources = self.filenames(src_link)
BuildPackage(script, sources, self.build_folder).build()
binary_list = self.search_in_tmp(prgnam)
try:
binary = (self.meta.output + max(binary_list)).split()
except ValueError:
Msg().build_FAILED(sbo_url, prgnam)
sys.exit(0)
if find_package(pkg + "-", self.meta.pkg_path):
print("{0}[ Upgrading ] --> {1}{2}".format(
self.meta.color["YELLOW"],
self.meta.color["ENDC"], pkg))
upgraded.append(prgnam)
else:
print("{0}[ Installing ] --> {1}{2}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"], pkg))
installs.append(prgnam)
PackageManager(binary).upgrade(flag="--install-new")
return installs, upgraded
def case_insensitive(self):
"""Matching packages distinguish between uppercase and
lowercase
"""
if "--case-ins" in self.flag:
data = []
for name in self.data[0]:
data.append(split_package(name)[0])
data_dict = Utils().case_sensitive(data)
for pkg in self.packages:
for key, value in data_dict.iteritems():
if key == pkg.lower():
index = self.packages.index(pkg)
self.packages[index] = value
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 search_pkg(name, repo):
"""Search if package exists in PACKAGES.TXT file
and return the name.
"""
PACKAGES_TXT = Utils().read_file(_meta_.lib_path + "{0}_repo/"
"PACKAGES.TXT".format(repo))
names = Utils().package_name(PACKAGES_TXT)
blacklist = BlackList().packages(pkgs=names, repo=repo)
for line in PACKAGES_TXT.splitlines():
status(0)
if line.startswith("PACKAGE NAME: ") and len(line) > 16:
pkg_name = split_package(line[15:])[0].strip()
if name == pkg_name and name not in blacklist:
return pkg_name
def sbo_upgrade(skip):
"""
Return packages for upgrade
"""
try:
Msg().checking()
upgrade_names = []
data = SBoGrep(name="").names()
blacklist = BlackList().packages(pkgs=data, repo="sbo")
for pkg in sbo_list():
status(0.02)
name = split_package(pkg)[0]
ver = split_package(pkg)[1]
if (name in data and name not in skip and name not in blacklist):
sbo_package = ("{0}-{1}".format(name, SBoGrep(name).version()))
package = ("{0}-{1}".format(name, ver))
if LooseVersion(sbo_package) > LooseVersion(package):
upgrade_names.append(name)
Msg().done()
return upgrade_names
except KeyboardInterrupt:
print("") # new line at exit
sys.exit(0)
def search_pkg(name, repo):
"""Search if package exists in PACKAGES.TXT file
and return the name.
"""
PACKAGES_TXT = Utils().read_file(_meta_.lib_path + "{0}_repo/"
"PACKAGES.TXT".format(repo))
names = Utils().package_name(PACKAGES_TXT)
blacklist = BlackList().packages(pkgs=names, repo=repo)
for line in PACKAGES_TXT.splitlines():
status(0)
if line.startswith("PACKAGE NAME: ") and len(line) > 16:
pkg_name = split_package(line[15:])[0].strip()
if name == pkg_name and name not in blacklist:
return pkg_name
def install(tmp_path, install_all):
'''
Install or upgrade packages
'''
for install in install_all:
package = (tmp_path + install).split()
if os.path.isfile(pkg_path + install[:-4]):
print("[ {0}reinstalling{1} ] --> {2}".format(
GREEN, ENDC, install))
PackageManager(package).reinstall()
elif find_package(split_package(install)[0] + "-", pkg_path):
print("[ {0}upgrading{1} ] --> {2}".format(YELLOW, ENDC, install))
PackageManager(package).upgrade()
else:
print("[ {0}installing{1} ] --> {2}".format(GREEN, ENDC, install))
PackageManager(package).upgrade()
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 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 views(install_all, comp_sum):
'''
Views packages
'''
pkg_sum = uni_sum = upg_sum = 0
for pkg, comp in zip(install_all, comp_sum):
pkg_split = split_package(pkg[:-4])
if os.path.isfile(pkg_path + pkg[:-4]):
pkg_sum += 1
COLOR = GREEN
elif find_package(pkg_split[0] + "-", pkg_path):
COLOR = YELLOW
upg_sum += 1
else:
COLOR = RED
uni_sum += 1
print(" {0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11:>12}{12}".format(
COLOR, pkg_split[0], ENDC, " " * (25 - len(pkg_split[0])),
pkg_split[1], " " * (19 - len(pkg_split[1])), pkg_split[2],
" " * (8 - len(pkg_split[2])), pkg_split[3],
" " * (7 - len(pkg_split[3])), "Slack", comp, " K"))
return [pkg_sum, upg_sum, uni_sum]
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 get_deps(self):
"""Grap package requirements from repositories
"""
if self.repo == "rlw":
dependencies = {}
rlw_deps = Utils().read_file(_meta_.conf_path + "rlworkman.deps")
for line in rlw_deps.splitlines():
if line and not line.startswith("#"):
pkgs = line.split(":")
dependencies[pkgs[0]] = pkgs[1]
if self.name in dependencies.keys():
return dependencies[self.name].split()
else:
return ""
else:
PACKAGES_TXT = Utils().read_file("{0}{1}_repo/PACKAGES.TXT".format(
_meta_.lib_path, self.repo))
for line in PACKAGES_TXT.splitlines():
if line.startswith("PACKAGE NAME:"):
pkg_name = split_package(line[14:].strip())[0]
if line.startswith("PACKAGE REQUIRED:"):
if pkg_name == self.name:
if line[18:].strip():
return self._req_fix(line)
def version(self):
"""Return version from installed packages
"""
if self.find:
return self.meta.sp + split_package(self.find)[1]
return ""
