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