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 __init__(self, name):
self.name = name
sys.stdout.write("{0}Reading package lists ...{1}".format(GREY, ENDC))
sys.stdout.flush()
initialization()
grep = SBoGrep(self.name)
self.sbo_url = sbo_search_pkg(self.name)
self.sbo_desc = grep.description()[len(self.name) + 2:-1]
self.sbo_req = grep.requires()
self.source_dwn = grep.source().split()
self.sbo_dwn = SBoLink(self.sbo_url).tar_gz()
self.sbo_version = grep.version()
self.space = ("\n" * 50)
sys.stdout.write("{0}Done{1}\n".format(GREY, ENDC))
def build_install(dependencies, sbo_versions, packages_arch):
'''
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
'''
installs, upgraded, versions = [], [], []
create_build_path()
os.chdir(build_path)
for pkg, ver, ar in zip(dependencies, sbo_versions, packages_arch):
prgnam = ("{0}-{1}".format(pkg, ver))
sbo_file = "".join(find_package(prgnam, pkg_path))
if sbo_file:
sbo_file_version = sbo_file[len(pkg) + 1:-len(ar) - 7]
template(78)
pkg_found(pkg, sbo_file_version)
template(78)
else:
sbo_url = sbo_search_pkg(pkg)
sbo_link = SBoLink(sbo_url).tar_gz()
src_link = SBoGrep(pkg).source().split()
script = sbo_link.split("/")[-1]
Download(build_path, sbo_link).start()
sources = dwn_sources(src_link)
BuildPackage(script, sources, build_path).build()
binary_list = search_in_tmp(prgnam)
try:
binary = (tmp + max(binary_list)).split()
except ValueError:
build_FAILED(sbo_url, prgnam)
sys.exit()
if find_package(pkg + sp, pkg_path):
print("{0}[ Upgrading ] --> {1}{2}".format(GREEN, ENDC, pkg))
upgraded.append(pkg)
else:
print("{0}[ Installing ] --> {1}{2}".format(GREEN, ENDC, pkg))
PackageManager(binary).upgrade()
installs.append(pkg)
versions.append(ver)
return [installs, upgraded, versions]
def build_install(dependencies, sbo_versions, packages_arch):
'''
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
'''
installs, upgraded, versions = [], [], []
create_build_path()
os.chdir(build_path)
for pkg, ver, ar in zip(dependencies, sbo_versions, packages_arch):
prgnam = ("{0}-{1}".format(pkg, ver))
sbo_file = "".join(find_package(prgnam, pkg_path))
if sbo_file:
sbo_file_version = sbo_file[len(pkg) + 1:-len(ar) - 7]
template(78)
pkg_found(pkg, sbo_file_version)
template(78)
else:
sbo_url = sbo_search_pkg(pkg)
sbo_link = SBoLink(sbo_url).tar_gz()
src_link = SBoGrep(pkg).source().split()
script = sbo_link.split("/")[-1]
Download(build_path, sbo_link).start()
sources = dwn_sources(src_link)
BuildPackage(script, sources, build_path).build()
binary_list = search_in_tmp(prgnam)
try:
binary = (tmp + max(binary_list)).split()
except ValueError:
build_FAILED(sbo_url, prgnam)
sys.exit()
if find_package(pkg + sp, pkg_path):
print("{0}[ Upgrading ] --> {1}{2}".format(GREEN, ENDC, pkg))
upgraded.append(pkg)
else:
print("{0}[ Installing ] --> {1}{2}".format(GREEN, ENDC, pkg))
PackageManager(binary).upgrade()
installs.append(pkg)
versions.append(ver)
return [installs, upgraded, versions]
def __init__(self, name):
self.name = name
sys.stdout.write("{0}Reading package lists ...{1}".format(GREY, ENDC))
sys.stdout.flush()
initialization()
grep = SBoGrep(self.name)
self.sbo_url = sbo_search_pkg(self.name)
self.sbo_desc = grep.description()[len(self.name) + 2:-1]
self.sbo_req = grep.requires()
self.source_dwn = grep.source().split()
self.sbo_dwn = SBoLink(self.sbo_url).tar_gz()
self.sbo_version = grep.version()
self.space = ("\n" * 50)
sys.stdout.write("{0}Done{1}\n".format(GREY, ENDC))
def __init__(self, name):
self.name = name
self.meta = _meta_
self.build_folder = self.meta.build_path
Msg().reading()
grep = SBoGrep(self.name)
self.data = SBoGrep(name="").names()
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
self.space = ("\n" * 50)
Msg().done()
class SBoNetwork(object):
def __init__(self, name):
self.name = name
sys.stdout.write("{0}Reading package lists ...{1}".format(GREY, ENDC))
sys.stdout.flush()
initialization()
grep = SBoGrep(self.name)
self.sbo_url = sbo_search_pkg(self.name)
self.sbo_desc = grep.description()[len(self.name) + 2:-1]
self.sbo_req = grep.requires()
self.source_dwn = grep.source().split()
self.sbo_dwn = SBoLink(self.sbo_url).tar_gz()
self.sbo_version = grep.version()
self.space = ("\n" * 50)
sys.stdout.write("{0}Done{1}\n".format(GREY, ENDC))
def view(self):
'''
View SlackBuild package, read or install them
from slackbuilds.org
'''
if self.sbo_url:
prgnam = ("{0}-{1}".format(self.name, self.sbo_version))
view_sbo(
self.name, self.sbo_url, self.sbo_desc,
self.sbo_dwn.split("/")[-1],
", ".join([src.split("/")[-1] for src in self.source_dwn]),
self.sbo_req)
FAULT = error_uns(self.source_dwn)
while True:
choice = read_choice()
if choice in ["D", "d"]:
download("", self.sbo_dwn, self.source_dwn)
break
elif choice in ["R", "r"]:
README = Read(self.sbo_url).readme("README")
fill = fill_pager(README)
pydoc.pager(README + fill)
elif choice in ["F", "f"]:
info = Read(self.sbo_url).info(self.name, ".info")
fill = fill_pager(info)
pydoc.pager(info + fill)
elif choice in ["S", "s"]:
SlackBuild = Read(self.sbo_url).slackbuild(
self.name, ".SlackBuild")
fill = fill_pager(SlackBuild)
pydoc.pager(SlackBuild + fill)
elif choice in ["B", "b"]:
build(self.sbo_dwn, self.source_dwn, FAULT)
break
elif choice in ["I", "i"]:
if not find_package(prgnam + sp, pkg_path):
build(self.sbo_dwn, self.source_dwn, FAULT)
install(self.name, prgnam, self.sbo_url)
break
else:
template(78)
pkg_found(self.name, self.sbo_version)
template(78)
break
else:
break
else:
pkg_not_found("\n", self.name, "Can't view", "\n")
def start(self):
'''
Upgrade all slackbuilds packages from slackbuilds.org
repository.
NOTE: This functions check packages by version not by build
tag because build tag not reported the SLACKBUILDS.TXT file,
but install the package with maximum build tag if find the
some version in /tmp directory.
'''
try:
if sbo_list():
upg_name = exists(self.index, self.toolbar_width)
sys.stdout.write(self.done)
data = []
if upg_name:
sys.stdout.write("{0}Resolving dependencies ...{1}".format(
GREY, ENDC))
sys.stdout.flush()
dependencies = deps(upg_name)
requires = one_for_all(dependencies)
dependencies_list = order_list(upg_name,
remove_dbs(requires))
# upgrade name = data[0]
# package for upgrade = data[1]
# upgrade version = data[2]
# upgrade arch = data[3]
data = store(dependencies_list)
sys.stdout.write(self.done)
if data:
# count installed = count[0]
# count upgraded = count[1]
# message install = msg[0]
# message upgrade = msg[1]
count, msg = view_packages(data[1], data[2], data[3])
read = raw_input("Would you like to upgrade [Y/n]? ")
if read == "Y" or read == "y":
create_build_path()
os.chdir(build_path)
for name, version in zip(data[0], data[2]):
prgnam = ("{0}-{1}".format(name, version))
sbo_url = sbo_search_pkg(name)
sbo_dwn = SBoLink(sbo_url).tar_gz()
src_dwn = SBoGrep(name).source().split()
script = sbo_dwn.split("/")[-1]
Download(build_path, sbo_dwn).start()
sources = dwn_sources(src_dwn)
BuildPackage(script, sources, build_path).build()
# 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.
binary_list = search_in_tmp(prgnam)
try:
binary = (tmp + max(binary_list)).split()
except ValueError:
build_FAILED(sbo_url, prgnam)
sys.exit()
if find_package(name + sp, pkg_path):
print("[ {0}Upgrading{1} ] --> {2}".format(
YELLOW, ENDC, name))
else:
print("[ {0}Installing{1} ] --> {2}".format(
GREEN, ENDC, name))
# Use this list to pick out what
# packages will be installed
self.installed.append(name)
PackageManager(binary).upgrade()
reference(data[0], data[1], data[2], count[0], count[1],
msg[0], msg[1], self.installed)
else:
print("\nTotal {0} SBo packages are up to date\n".format(
len(sbo_list())))
else:
sys.stdout.write(self.done)
print("\nNo SBo packages found\n")
except KeyboardInterrupt:
print # new line at exit
sys.exit()
class SBoNetwork(object):
def __init__(self, name):
self.name = name
sys.stdout.write("{0}Reading package lists ...{1}".format(GREY, ENDC))
sys.stdout.flush()
initialization()
grep = SBoGrep(self.name)
self.sbo_url = sbo_search_pkg(self.name)
self.sbo_desc = grep.description()[len(self.name) + 2:-1]
self.sbo_req = grep.requires()
self.source_dwn = grep.source().split()
self.sbo_dwn = SBoLink(self.sbo_url).tar_gz()
self.sbo_version = grep.version()
self.space = ("\n" * 50)
sys.stdout.write("{0}Done{1}\n".format(GREY, ENDC))
def view(self):
'''
View SlackBuild package, read or install them
from slackbuilds.org
'''
if self.sbo_url:
prgnam = ("{0}-{1}".format(self.name, self.sbo_version))
view_sbo(self.name, self.sbo_url, self.sbo_desc,
self.sbo_dwn.split("/")[-1],
", ".join([src.split("/")[-1] for src in self.source_dwn]),
self.sbo_req)
FAULT = error_uns(self.source_dwn)
while True:
choice = read_choice()
if choice in ["D", "d"]:
download("", self.sbo_dwn, self.source_dwn)
break
elif choice in ["R", "r"]:
README = Read(self.sbo_url).readme("README")
fill = fill_pager(README)
pydoc.pager(README + fill)
elif choice in ["F", "f"]:
info = Read(self.sbo_url).info(self.name, ".info")
fill = fill_pager(info)
pydoc.pager(info + fill)
elif choice in ["S", "s"]:
SlackBuild = Read(self.sbo_url).slackbuild(self.name,
".SlackBuild")
fill = fill_pager(SlackBuild)
pydoc.pager(SlackBuild + fill)
elif choice in ["B", "b"]:
build(self.sbo_dwn, self.source_dwn, FAULT)
break
elif choice in ["I", "i"]:
if not find_package(prgnam + sp, pkg_path):
build(self.sbo_dwn, self.source_dwn, FAULT)
install(self.name, prgnam, self.sbo_url)
break
else:
template(78)
pkg_found(self.name, self.sbo_version)
template(78)
break
else:
break
else:
pkg_not_found("\n", self.name, "Can't view", "\n")
class SBoNetwork(object):
def __init__(self, name):
self.name = name
self.meta = _meta_
self.build_folder = self.meta.build_path
Msg().reading()
grep = SBoGrep(self.name)
self.data = SBoGrep(name="").names()
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
self.space = ("\n" * 50)
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:
prgnam = ("{0}-{1}".format(self.name, self.sbo_version))
self.view_sbo(
self.name, self.sbo_url, self.sbo_desc,
self.sbo_dwn.split("/")[-1],
", ".join([src.split("/")[-1] for src in self.source_dwn]),
self.sbo_req)
FAULT = self.error_uns()
while True:
choice = self.read_choice()
if choice in ["D", "d"]:
Download(path="", url=self.dwn_srcs, repo="sbo").start()
break
elif choice in ["R", "r"]:
README = Read(self.sbo_url).readme("README")
fill = self.fill_pager(README)
pydoc.pager(README + fill)
elif choice in ["F", "f"]:
info = Read(self.sbo_url).info(self.name, ".info")
fill = self.fill_pager(info)
pydoc.pager(info + fill)
elif choice in ["S", "s"]:
SlackBuild = Read(self.sbo_url).slackbuild(self.name,
".SlackBuild")
fill = self.fill_pager(SlackBuild)
pydoc.pager(SlackBuild + fill)
elif choice in ["B", "b"]:
self.build(FAULT)
delete(self.build_folder)
break
elif choice in ["I", "i"]:
if not find_package(prgnam + self.meta.sp,
self.meta.pkg_path):
self.build(FAULT)
self.install(prgnam)
delete(self.build_folder)
break
else:
Msg().template(78)
Msg().pkg_found(self.name, self.sbo_version)
Msg().template(78)
break
else:
break
else:
Msg().pkg_not_found("\n", self.name, "Can't view", "\n")
@staticmethod
def view_sbo(*args):
"""
View slackbuild.org
"""
br1, br2, fix_sp = "", "", " "
if _meta_.use_colors in ["off", "OFF"]:
br1 = "("
br2 = ")"
fix_sp = ""
color = _meta_.color
print("") # new line at start
Msg().template(78)
print("| {0}Package {1}{2}{3} --> {4}".format(color["GREEN"],
color["CYAN"], args[0],
color["GREEN"],
color["ENDC"] + args[1]))
Msg().template(78)
print("| {0}Description : {1}{2}".format(color["GREEN"],
color["ENDC"], args[2]))
print("| {0}SlackBuild : {1}{2}".format(color["GREEN"], color["ENDC"],
args[3]))
print("| {0}Sources : {1}{2}".format(color["GREEN"], color["ENDC"],
args[4]))
print("| {0}Requirements : {1}{2}".format(color["YELLOW"],
color["ENDC"],
", ".join(args[5])))
Msg().template(78)
print("| {0}R{1}{2}EADME View the README file".format(
color["RED"], color["ENDC"], br2))
print("| {0}S{1}{2}lackBuild View the SlackBuild file".format(
color["RED"], color["ENDC"], br2))
print("| In{0}{1}f{2}{3}o{4} View the Info file".format(
br1, color["RED"], color["ENDC"], br2, fix_sp))
print("| {0}D{1}{2}ownload Download this package".format(
color["RED"], color["ENDC"], br2))
print("| {0}B{1}{2}uild Download and build".format(
color["RED"], color["ENDC"], br2))
print("| {0}I{1}{2}nstall Download/Build/Install".format(
color["RED"], color["ENDC"], br2))
print("| {0}Q{1}{2}uit Quit".format(color["RED"],
color["ENDC"], br2))
Msg().template(78)
@staticmethod
def fill_pager(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 read_choice(self):
"""
Return choice
"""
try:
choice = raw_input("{0} Choose an option > {1}".format(
_meta_.color["GREY"], _meta_.color["ENDC"]))
except KeyboardInterrupt:
print("") # new line at exit
sys.exit(0)
return choice
def error_uns(self):
"""
Check if package supported by arch
before proceed to install
"""
UNST = ["UNSUPPORTED", "UNTESTED"]
if "".join(self.source_dwn) in UNST:
return "".join(self.source_dwn)
def build(self, FAULT):
"""
Only build and create Slackware package
"""
if FAULT:
print("\n{0}The package {1} {2}\n".format(_meta_.color["RED"],
FAULT,
_meta_.color["ENDC"]))
sys.exit(0)
sources = []
if not os.path.exists(_meta_.build_path):
os.makedirs(_meta_.build_path)
os.chdir(_meta_.build_path)
Download(_meta_.build_path, self.dwn_srcs, repo="sbo").start()
script = self.sbo_dwn.split("/")[-1]
for src in self.source_dwn:
sources.append(src.split("/")[-1])
BuildPackage(script, sources, _meta_.build_path).build()
def install(self, prgnam):
"""
Install Slackware package found in /tmp
directory.
"""
binary_list = []
for search in find_package(prgnam, _meta_.output):
if "_SBo" in search:
binary_list.append(search)
try:
binary = (_meta_.output + max(binary_list)).split()
except ValueError:
Msg().build_FAILED(self.sbo_url, prgnam)
sys.exit(0)
print("[ {0}Installing{1} ] --> {2}".format(_meta_.color["GREEN"],
_meta_.color["ENDC"],
self.name))
PackageManager(binary).upgrade(flag="--install-new")
