def store(*args): ''' Store and return packages for upgrading ''' (dwn, upgrade, comp_sum, uncomp_sum) = ([] for i in range(4)) if args[4] == "stable": # stables versions upgrade for name, loc, comp, uncomp in zip(args[0], args[1], args[2], args[3]): if (not os.path.isfile(pkg_path + name[:-4]) and split_package( name)[0] not in BlackList().packages()): dwn.append("{0}{1}/{2}".format( mirrors("", "", args[4]), loc, name)) comp_sum.append(comp) uncomp_sum.append(uncomp) upgrade.append(name) else: # current version upgrade installed = [] # get all installed packages and store the package name. for pkg in os.listdir(pkg_path): installed.append(split_package(pkg)[0]) for name, loc, comp, uncomp in zip(args[0], args[1], args[2], args[3]): # If the package from the current repository is installed # (check with the name) but not is in the path (check with # all package like 'apr-1.5.0-x86_64-1') then add to list for # upgrade. # etc. 'apr' in list 'installed' ?? if yes 'apr-1.5.0-x86_64-1' # exist in /var/log/packages ?? if no add to upgrade. if split_package(name)[0] in installed: if (not os.path.isfile(pkg_path + name[:-4]) and split_package(name)[0] not in BlackList().packages()): dwn.append("{0}{1}/{2}".format( mirrors("", "", args[4]), loc, name)) comp_sum.append(comp) uncomp_sum.append(uncomp) upgrade.append(name) return [dwn, upgrade, comp_sum, uncomp_sum]
def pkg_upgrade(repo, skip, flag): """Checking packages for upgrade """ Msg().checking() PACKAGES_TXT = RepoInit(repo).fetch()[0] pkgs_for_upgrade = [] # name = data[0] # location = data[1] # size = data[2] # unsize = data[3] data = repo_data(PACKAGES_TXT, repo, flag="") for pkg in installed(): status(0.0005) inst_pkg = split_package(pkg) for name in data[0]: if name: # this tips because some pkg_name is empty repo_pkg = split_package(name[:-4]) if (repo_pkg[0] == inst_pkg[0] and LooseVersion(repo_pkg[1]) > LooseVersion(inst_pkg[1]) and repo_pkg[3] >= inst_pkg[3] and inst_pkg[0] not in skip and repo_pkg[1] != "blacklist"): pkgs_for_upgrade.append(repo_pkg[0]) Msg().done() if "--checklist" in flag: pkgs_for_upgrade = choose_upg(pkgs_for_upgrade) return pkgs_for_upgrade
def store(*args): ''' Store and return packages for upgrading ''' (dwn, upgrade, comp_sum, uncomp_sum) = ([] for i in range(4)) if args[4] == "stable": # stables versions upgrade for name, loc, comp, uncomp in zip(args[0], args[1], args[2], args[3]): if (not os.path.isfile(pkg_path + name[:-4]) and split_package(name)[0] not in BlackList().packages()): dwn.append("{0}{1}/{2}".format(mirrors("", "", args[4]), loc, name)) comp_sum.append(comp) uncomp_sum.append(uncomp) upgrade.append(name) else: # current version upgrade installed = [] # get all installed packages and store the package name. for pkg in os.listdir(pkg_path): installed.append(split_package(pkg)[0]) for name, loc, comp, uncomp in zip(args[0], args[1], args[2], args[3]): # If the package from the current repository is installed # (check with the name) but not is in the path (check with # all package like 'apr-1.5.0-x86_64-1') then add to list for # upgrade. # etc. 'apr' in list 'installed' ?? if yes 'apr-1.5.0-x86_64-1' # exist in /var/log/packages ?? if no add to upgrade. if split_package(name)[0] in installed: if (not os.path.isfile(pkg_path + name[:-4]) and split_package(name)[0] not in BlackList().packages()): dwn.append("{0}{1}/{2}".format(mirrors("", "", args[4]), loc, name)) comp_sum.append(comp) uncomp_sum.append(uncomp) upgrade.append(name) return [dwn, upgrade, comp_sum, uncomp_sum]
def pkg_upgrade(repo, skip, flag): """ Checking packages for upgrade """ Msg().checking() PACKAGES_TXT = RepoInit(repo).fetch()[0] pkgs_for_upgrade = [] # name = data[0] # location = data[1] # size = data[2] # unsize = data[3] data = repo_data(PACKAGES_TXT, repo, flag="") for pkg in installed(): status(0.0005) inst_pkg = split_package(pkg) for name in data[0]: if name: # this tips because some pkg_name is empty repo_pkg = split_package(name[:-4]) if (repo_pkg[0] == inst_pkg[0] and LooseVersion(repo_pkg[1]) > LooseVersion(inst_pkg[1]) and repo_pkg[3] >= inst_pkg[3] and inst_pkg[0] not in skip and repo_pkg[1] != "blacklist"): pkgs_for_upgrade.append(repo_pkg[0]) Msg().done() if "--checklist" in flag: pkgs_for_upgrade = choose_upg(pkgs_for_upgrade) return pkgs_for_upgrade
def install_packages(self): """Install or upgrade packages """ installs, upgraded = [], [] for inst in (self.dep_install + self.install): package = (self.tmp_path + inst).split() pkg_ver = "{0}-{1}".format(split_package(inst)[0], split_package(inst)[1]) self.checksums(inst) if os.path.isfile(self.meta.pkg_path + inst[:-4]): print("[ {0}reinstalling{1} ] --> {2}".format( self.meta.color["GREEN"], self.meta.color["ENDC"], inst)) installs.append(pkg_ver) PackageManager(package).upgrade("--reinstall") elif GetFromInstalled(split_package(inst)[0]).name(): print("[ {0}upgrading{1} ] --> {2}".format( self.meta.color["YELLOW"], self.meta.color["ENDC"], inst)) upgraded.append(pkg_ver) PackageManager(package).upgrade("--install-new") else: print("[ {0}installing{1} ] --> {2}".format( self.meta.color["GREEN"], self.meta.color["ENDC"], inst)) installs.append(pkg_ver) PackageManager(package).upgrade("--install-new") return [installs, upgraded]
def upgrade(self): """ Upgrade packages """ for pkg in self.upgrade_all: check_md5(pkg_checksum(pkg, "slack_patches"), self.patch_path + pkg) pkg_ver = "{0}-{1}".format( split_package(pkg)[0], split_package(pkg)[1]) if find_package( split_package(pkg)[0] + self.meta.sp, self.meta.pkg_path): print("[ {0}upgrading{1} ] --> {2}".format( self.meta.color["YELLOW"], self.meta.color["ENDC"], pkg[:-4])) PackageManager( (self.patch_path + pkg).split()).upgrade("--install-new") self.upgraded.append(pkg_ver) else: print("[ {0}installing{1} ] --> {2}".format( self.meta.color["GREEN"], self.meta.color["ENDC"], pkg[:-4])) PackageManager( (self.patch_path + pkg).split()).upgrade("--install-new") self.installed.append(pkg_ver)
def store(self, packages): """Store and return packages for install """ dwn, install, comp_sum, uncomp_sum = ([] for i in range(4)) # name = data[0] # location = data[1] # size = data[2] # unsize = data[3] for pkg in packages: for pk, loc, comp, uncomp in zip(self.data[0], self.data[1], self.data[2], self.data[3]): if (pk and pkg == split_package(pk)[0] and pk not in install and split_package(pk)[0] not in self.blacklist): dwn.append("{0}{1}/{2}".format(self.mirror, loc, pk)) install.append(pk) comp_sum.append(comp) uncomp_sum.append(uncomp) if not install: for pkg in packages: for pk, loc, comp, uncomp in zip(self.data[0], self.data[1], self.data[2], self.data[3]): name = split_package(pk)[0] if (pk and pkg in name and name not in self.blacklist): dwn.append("{0}{1}/{2}".format(self.mirror, loc, pk)) install.append(pk) comp_sum.append(comp) uncomp_sum.append(uncomp) dwn.reverse() install.reverse() comp_sum.reverse() uncomp_sum.reverse() return [dwn, install, comp_sum, uncomp_sum]
def pkg_upgrade(repo, skip): """ Checking packages for upgrade """ try: Msg().checking() PACKAGES_TXT = RepoInit(repo).fetch()[0] pkgs_for_upgrade = [] # name = data[0] # location = data[1] # size = data[2] # unsize = data[3] data = repo_data(PACKAGES_TXT, repo, flag="") for pkg in installed(): status(0.0005) inst_pkg = split_package(pkg) for name in data[0]: if name: # this tips because some pkg_name is empty repo_pkg = split_package(name[:-4]) if ( repo_pkg[0] == inst_pkg[0] and LooseVersion(repo_pkg[1]) > LooseVersion(inst_pkg[1]) and repo_pkg[3] >= inst_pkg[3] and inst_pkg[0] not in skip ): pkgs_for_upgrade.append(repo_pkg[0]) Msg().done() return pkgs_for_upgrade except KeyboardInterrupt: print("") # new line at exit sys.exit(0)
def not_downgrade(self, package): """Don't downgrade packages if repository version is lower than installed""" name = split_package(package)[0] rep_ver = split_package(package)[1] ins_ver = GetFromInstalled(name).version()[1:] if not ins_ver: ins_ver = "0" if LooseVersion(rep_ver) < LooseVersion(ins_ver): self.msg.template(78) print("| Package {0} don't downgrade, " "setting by user".format(name)) self.msg.template(78) return True
def list_of_installed(self, repo, name): """Return installed packages """ all_installed_names = [] all_installed_packages = find_package("", self.meta.pkg_path) for inst in all_installed_packages: if repo == "sbo" and inst.endswith("_SBo"): name = split_package(inst)[0] all_installed_names.append(name) else: if name: all_installed_names.append(split_package(inst)[0]) else: all_installed_names.append(inst) return all_installed_names
def __init__(self, packages, repo, flag): self.packages = packages pkg_security(packages) self.repo = repo self.flag = flag self.meta = _meta_ self.msg = Msg() self.version = self.meta.slack_rel self.tmp_path = self.meta.slpkg_tmp_packages for fl in self.flag: if fl.startswith("--directory-prefix="): self.tmp_path = fl.split("=")[1] if not self.tmp_path.endswith("/"): self.tmp_path += "/" self.dwn, self.dep_dwn = [], [] self.install, self.dep_install = [], [] self.comp_sum, self.dep_comp_sum = [], [] self.uncomp_sum, self.dep_uncomp_sum = [], [] self.dependencies = [] self.deps_dict = {} self.answer = "" self.msg.reading() self.PACKAGES_TXT, self.mirror = RepoInit(self.repo).fetch() self.data = repo_data(self.PACKAGES_TXT, self.repo, self.flag) self.repo_pkg_names = [] for name in self.data[0]: self.repo_pkg_names.append(split_package(name)[0]) self.blacklist = BlackList().packages(self.data[0], self.repo) self.matching = False
def views(self, install, comp_sum): """Views packages """ pkg_sum = uni_sum = upg_sum = 0 # fix repositories align repo = self.repo + (" " * (6 - (len(self.repo)))) for pkg, comp in zip(install, comp_sum): pkg_repo = split_package(pkg[:-4]) if find_package(pkg[:-4], self.meta.pkg_path): pkg_sum += 1 COLOR = self.meta.color["GREEN"] elif pkg_repo[0] == GetFromInstalled(pkg_repo[0]).name(): COLOR = self.meta.color["YELLOW"] upg_sum += 1 else: COLOR = self.meta.color["RED"] uni_sum += 1 ver = GetFromInstalled(pkg_repo[0]).version() print(" {0}{1}{2}{3} {4}{5} {6}{7}{8}{9}{10}{11:>11}{12}".format( COLOR, pkg_repo[0] + ver, self.meta.color["ENDC"], " " * (23-len(pkg_repo[0] + ver)), pkg_repo[1], " " * (18-len(pkg_repo[1])), pkg_repo[2], " " * (8-len(pkg_repo[2])), pkg_repo[3], " " * (7-len(pkg_repo[3])), repo, comp, " K")).rstrip() return [pkg_sum, upg_sum, uni_sum]
def choose_upg(packages): """Create checklist to choose packages for upgrade """ selected_packages, data = [], [] if packages: for pkg in packages: name = GetFromInstalled(pkg).name() ver = GetFromInstalled(pkg).version() binary = "{0}{1}".format(name, ver) installed = find_package(binary + _meta_.sp, _meta_.pkg_path)[0] data.append(installed) text = "Press 'spacebar' to unchoose packages from upgrade" title = " Upgrade " backtitle = "{0} {1}".format(_meta_.__all__, _meta_.__version__) status = True pkgs = DialogUtil(data, text, title, backtitle, status).checklist() pkgs = [] if pkgs is None else pkgs for pkg in pkgs: name = split_package(pkg)[0] if name in packages: selected_packages.append(name) if not selected_packages: raise SystemExit() print("") return selected_packages
def get_deps(self): """Grap package requirements from repositories """ if self.repo == "rlw": # Robby"s repository dependencies as shown in the central page # http://rlworkman.net/pkgs/ dependencies = { "abiword": "wv", "claws-mail": "libetpan", "inkscape": "gtkmm atkmm pangomm cairomm mm-common libsigc++ " "libwpg lxml gsl numpy BeautifulSoup", "texlive": "libsigsegv texi2html", "xfburn": "libburn libisofs" } if self.name in dependencies.keys(): return dependencies[self.name].split() else: return "" else: PACKAGES_TXT = Utils().read_file("{0}{1}_repo/PACKAGES.TXT".format( _meta_.lib_path, self.repo)) for line in PACKAGES_TXT.splitlines(): if line.startswith("PACKAGE NAME:"): pkg_name = split_package(line[14:].strip())[0] if line.startswith("PACKAGE REQUIRED:"): if pkg_name == self.name: if line[18:].strip(): return self._req_fix(line)
def store(dependencies_list): ''' In the end lest a check of the packages that are on the list are already installed. ''' (upgrade_name, package_for_upgrade, upgrade_version, upgrade_arch ) = ([] for i in range(4)) for pkg in dependencies_list: ver = SBoGrep(pkg).version() prgnam = ("{0}-{1}".format(pkg, ver)) # if package not installed # take version from repository pkg_version = ver arch = os.uname()[4] if arch.startswith("i") and arch.endswith("86"): arch = "i486" if find_package(prgnam, pkg_path) == []: for sbo in os.listdir(pkg_path): if (sbo.startswith(pkg + sp) and sbo.endswith("_SBo")): # search if packages installed # if yes grab package name and version pkg_version = split_package(sbo)[1] upgrade_name.append(pkg) package_for_upgrade.append("{0}-{1}".format(pkg, pkg_version)) upgrade_version.append(ver) upgrade_arch.append(arch) return [upgrade_name, package_for_upgrade, upgrade_version, upgrade_arch]
def add(self, repo, pkg): """Split packages by repository """ if repo == "sbo": return pkg else: return split_package(pkg)[0]
def _view_removed(self): """View packages before removed """ print("\nPackages with name matching [ {0}{1}{2} ]\n".format( self.meta.color["CYAN"], ", ".join(self.binary), self.meta.color["ENDC"])) removed, packages = self._get_removed() if packages and "--checklist" in self.extra: removed = [] text = "Press 'spacebar' to unchoose packages from the remove" backtitle = "{0} {1}".format(self.meta.__all__, self.meta.__version__) status = True pkgs = DialogUtil(packages, text, " Remove ", backtitle, status).checklist() if pkgs: for rmv in pkgs: removed.append(split_package(rmv)[0]) self.meta.default_answer = "y" else: for rmv, pkg in zip(removed, packages): print("[ {0}delete{1} ] --> {2}".format( self.meta.color["RED"], self.meta.color["ENDC"], pkg)) self._sizes(pkg) self._calc_sizes() self._remove_summary() return removed
def _get_removed(self): """Manage removed packages by extra options """ removed, packages = [], [] if "--tag" in self.extra: for pkg in find_package("", self.meta.pkg_path): for tag in self.binary: if pkg.endswith(tag): removed.append(split_package(pkg)[0]) packages.append(pkg) if not removed: self.msg.pkg_not_found("", "'tag'", "Can't remove", "\n") raise SystemExit(1) else: for pkg in self.binary: name = GetFromInstalled(pkg).name() ver = GetFromInstalled(pkg).version() package = find_package("{0}{1}{2}".format( name, ver, self.meta.sp), self.meta.pkg_path) if pkg and name == pkg: removed.append(pkg) packages.append(package[0]) else: self.msg.pkg_not_found("", pkg, "Can't remove", "\n") raise SystemExit(1) return removed, packages
def _view_removed(self): """View packages before removed """ print("\nPackages with name matching [ {0}{1}{2} ]\n".format( self.meta.color["CYAN"], ", ".join(self.binary), self.meta.color["ENDC"])) removed, packages = self._get_removed() if packages and "--checklist" in self.extra: removed = [] data = packages text = "Press 'spacebar' to unchoose packages from remove" title = "Remove" backtitle = "{0} {1}".format(self.meta.__all__, self.meta.__version__) status = True pkgs = DialogUtil(data, text, title, backtitle, status).checklist() if pkgs: for rmv in pkgs: removed.append(split_package(rmv)[0]) self.meta.default_answer = "y" else: for rmv, pkg in zip(removed, packages): print("[ {0}delete{1} ] --> {2}".format( self.meta.color["RED"], self.meta.color["ENDC"], pkg)) self._sizes(pkg) self._calc_sizes() self._remove_summary() return removed
def package_name(self, PACKAGES_TXT): """Returns list with all the names of packages repository """ packages = [] for line in PACKAGES_TXT.splitlines(): if line.startswith("PACKAGE NAME:"): packages.append(split_package(line[14:].strip())[0]) return packages
def exists(index, toolbar_width): ''' search packages if exists in the repository and it gets to avoidable modified packages from the user with the tag _SBo ''' upgrade_names = [] for pkg in sbo_list(): index += 1 toolbar_width = status(index, toolbar_width, 4) name = split_package(pkg)[0] if sbo_search_pkg(name): sbo_package = ("{0}-{1}".format(name, SBoGrep(name).version())) package = ("{0}-{1}".format(name, split_package(pkg)[1])) if sbo_package > package: upgrade_names.append(name) return upgrade_names
def _splitting_packages(self, pkg, repo, name): """Return package name from repositories """ if name and repo != "sbo": pkg = split_package(pkg)[0] elif not name and repo != "sbo": pkg = pkg[:-4] return pkg
def __init__(self, package): self.package = package self.meta = _meta_ self.files = find_package(self.package + self.meta.sp, self.meta.pkg_path) self.find = "" for f in self.files: if split_package(f)[0] == self.package: self.find = f
def find_package(find_pkg, directory): ''' Find packages ''' pkgs = [] blacklist = BlackList().packages() for pkg in sorted(os.listdir(directory)): if pkg.startswith(find_pkg) and split_package(pkg)[0] not in blacklist: pkgs.append(pkg) return pkgs
def views(upgrade_all, comp_sum): ''' Views packages ''' for upgrade, size in zip(upgrade_all, comp_sum): pkg_split = split_package(upgrade[:-4]) print(" {0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11:>12}{12}".format( YELLOW, pkg_split[0], ENDC, " " * (25 - len(pkg_split[0])), pkg_split[1], " " * (19 - len(pkg_split[1])), pkg_split[2], " " * (8 - len(pkg_split[2])), pkg_split[3], " " * (7 - len(pkg_split[3])), "Slack", size, " K"))
def sbo_upgrade(skip, flag): """Return packages for upgrade """ Msg().checking() upgrade_names = [] data = SBoGrep(name="").names() blacklist = BlackList().packages(pkgs=data, repo="sbo") for pkg in sbo_list(): status(0.02) name = split_package(pkg)[0] ver = split_package(pkg)[1] if (name in data and name not in skip and name not in blacklist): sbo_package = ("{0}-{1}".format(name, SBoGrep(name).version())) package = ("{0}-{1}".format(name, ver)) if LooseVersion(sbo_package) > LooseVersion(package): upgrade_names.append(name) Msg().done() if "--checklist" in flag: upgrade_names = choose_upg(upgrade_names) return upgrade_names
def slack_package(prgnam): """Search for binary packages in output directory """ binary = "" # Get build number from prgnam.SlackBuild script build1 = BuildNumber("", "-".join(prgnam.split("-")[:-1])).get() for pkg in find_package(prgnam + _meta_.sp, _meta_.output): name = split_package(pkg[:-4])[0] ver = split_package(pkg[:-4])[1] prgnam_find = "{0}-{1}".format(name, ver) # Get build number from binary package build2 = split_package(pkg[:-4])[3] if (pkg[:-4].endswith("_SBo") and prgnam_find == prgnam and build1 == build2): binary = pkg break if binary not in sbo_packages(): Msg().build_FAILED(prgnam) raise SystemExit() return ["".join(_meta_.output + binary)]
def alien_filter(packages, sizes): """This filter avoid list double packages from alien repository """ cache, npkg, nsize = [], [], [] for p, s in zip(packages, sizes): name = split_package(p)[0] if name not in cache: cache.append(name) npkg.append(p) nsize.append(s) return npkg, nsize
def views(upgrade_all, comp_sum): ''' Views packages ''' for upgrade, size in zip(upgrade_all, comp_sum): pkg_split = split_package(upgrade[:-4]) print(" {0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11:>12}{12}".format( YELLOW, pkg_split[0], ENDC, " " * (25-len(pkg_split[0])), pkg_split[1], " " * (19-len(pkg_split[1])), pkg_split[2], " " * (8-len(pkg_split[2])), pkg_split[3], " " * (7-len(pkg_split[3])), "Slack", size, " K"))
def find_package(find_pkg, directory): """Find packages """ pkgs = [] if os.path.isdir(directory): installed = sorted(os.listdir(directory)) blacklist = BlackList().packages(pkgs=installed, repo="local") if os.path.exists(directory): for pkg in installed: if (not pkg.startswith(".") and pkg.startswith(find_pkg) and split_package(pkg)[0] not in blacklist): pkgs.append(pkg) return pkgs
def upgrade(self): """ Upgrade packages """ for pkg in self.upgrade_all: check_md5(pkg_checksum(pkg, "slack_patches"), self.patch_path + pkg) pkg_ver = "{0}-{1}".format(split_package(pkg)[0], split_package(pkg)[1]) if find_package(split_package(pkg)[0] + "-", self.meta.pkg_path): print("[ {0}upgrading{1} ] --> {2}".format( self.meta.color["YELLOW"], self.meta.color["ENDC"], pkg[:-4])) PackageManager((self.patch_path + pkg).split()).upgrade( "--install-new") self.upgraded.append(pkg_ver) else: print("[ {0}installing{1} ] --> {2}".format( self.meta.color["GREEN"], self.meta.color["ENDC"], pkg[:-4])) PackageManager((self.patch_path + pkg).split()).upgrade( "--install-new") self.installed.append(pkg_ver)
def build_install(self): """Searches the package name and version in /tmp to install. If find two or more packages e.g. to build tag 2 or 3 will fit most. """ slackbuilds = self.dependencies + self.master_packages installs, upgraded, = [], [] if not os.path.exists(self.build_folder): os.makedirs(self.build_folder) os.chdir(self.build_folder) for sbo in slackbuilds: pkg = "-".join(sbo.split("-")[:-1]) ver = sbo.split("-")[-1] prgnam = ("{0}-{1}".format(pkg, ver)) sbo_file = "".join(find_package(prgnam, self.meta.pkg_path)) src_link = SBoGrep(pkg).source().split() if sbo_file: Msg().template(78) Msg().pkg_found(pkg, split_package(sbo_file)[1]) Msg().template(78) elif self.unst[0] in src_link or self.unst[1] in src_link: Msg().template(78) print("| Package {0} {1}{2}{3}".format( sbo, self.meta.color["RED"], "".join(src_link), self.meta.color["ENDC"])) Msg().template(78) else: sbo_url = sbo_search_pkg(pkg) sbo_link = SBoLink(sbo_url).tar_gz() script = sbo_link.split("/")[-1] dwn_srcs = sbo_link.split() + src_link Download(self.build_folder, dwn_srcs, repo="sbo").start() sources = self.filenames(src_link) BuildPackage(script, sources, self.build_folder).build() binary_list = self.search_in_tmp(prgnam) try: binary = (self.meta.output + max(binary_list)).split() except ValueError: Msg().build_FAILED(sbo_url, prgnam) sys.exit(0) if find_package(pkg + "-", self.meta.pkg_path): print("{0}[ Upgrading ] --> {1}{2}".format( self.meta.color["YELLOW"], self.meta.color["ENDC"], pkg)) upgraded.append(prgnam) else: print("{0}[ Installing ] --> {1}{2}".format( self.meta.color["GREEN"], self.meta.color["ENDC"], pkg)) installs.append(prgnam) PackageManager(binary).upgrade(flag="--install-new") return installs, upgraded
def case_insensitive(self): """Matching packages distinguish between uppercase and lowercase """ if "--case-ins" in self.flag: data = [] for name in self.data[0]: data.append(split_package(name)[0]) data_dict = Utils().case_sensitive(data) for pkg in self.packages: for key, value in data_dict.iteritems(): if key == pkg.lower(): index = self.packages.index(pkg) self.packages[index] = value
def install_packages(self): """Install or upgrade packages """ installs, upgraded = [], [] for inst in (self.dep_install + self.install): package = (self.tmp_path + inst).split() pkg_ver = "{0}-{1}".format(split_package(inst)[0], split_package(inst)[1]) self.checksums(inst) if GetFromInstalled(split_package(inst)[0]).name(): print("[ {0}upgrading{1} ] --> {2}".format( self.meta.color["YELLOW"], self.meta.color["ENDC"], inst)) upgraded.append(pkg_ver) if "--reinstall" in self.flag: PackageManager(package).upgrade("--reinstall") else: PackageManager(package).upgrade("--install-new") else: print("[ {0}installing{1} ] --> {2}".format( self.meta.color["GREEN"], self.meta.color["ENDC"], inst)) installs.append(pkg_ver) PackageManager(package).upgrade("--install-new") return [installs, upgraded]
def search_pkg(name, repo): """Search if package exists in PACKAGES.TXT file and return the name. """ PACKAGES_TXT = Utils().read_file(_meta_.lib_path + "{0}_repo/" "PACKAGES.TXT".format(repo)) names = Utils().package_name(PACKAGES_TXT) blacklist = BlackList().packages(pkgs=names, repo=repo) for line in PACKAGES_TXT.splitlines(): status(0) if line.startswith("PACKAGE NAME: ") and len(line) > 16: pkg_name = split_package(line[15:])[0].strip() if name == pkg_name and name not in blacklist: return pkg_name
def sbo_upgrade(skip): """ Return packages for upgrade """ try: Msg().checking() upgrade_names = [] data = SBoGrep(name="").names() blacklist = BlackList().packages(pkgs=data, repo="sbo") for pkg in sbo_list(): status(0.02) name = split_package(pkg)[0] ver = split_package(pkg)[1] if (name in data and name not in skip and name not in blacklist): sbo_package = ("{0}-{1}".format(name, SBoGrep(name).version())) package = ("{0}-{1}".format(name, ver)) if LooseVersion(sbo_package) > LooseVersion(package): upgrade_names.append(name) Msg().done() return upgrade_names except KeyboardInterrupt: print("") # new line at exit sys.exit(0)
def install(tmp_path, install_all): ''' Install or upgrade packages ''' for install in install_all: package = (tmp_path + install).split() if os.path.isfile(pkg_path + install[:-4]): print("[ {0}reinstalling{1} ] --> {2}".format( GREEN, ENDC, install)) PackageManager(package).reinstall() elif find_package(split_package(install)[0] + "-", pkg_path): print("[ {0}upgrading{1} ] --> {2}".format(YELLOW, ENDC, install)) PackageManager(package).upgrade() else: print("[ {0}installing{1} ] --> {2}".format(GREEN, ENDC, install)) PackageManager(package).upgrade()
def views(self): """ Views packages """ for upg, size in sorted(zip(self.upgrade_all, self.comp_sum)): pkg_repo = split_package(upg[:-4]) color = self.meta.color["RED"] pkg_inst = GetFromInstalled(pkg_repo[0]).name() if pkg_repo[0] == pkg_inst: color = self.meta.color["YELLOW"] ver = GetFromInstalled(pkg_repo[0]).version() print(" {0}{1}{2}{3} {4}{5} {6}{7}{8}{9}{10}{11:>12}{12}".format( color, pkg_repo[0] + ver, self.meta.color["ENDC"], " " * (23 - len(pkg_repo[0] + ver)), pkg_repo[1], " " * (18 - len(pkg_repo[1])), pkg_repo[2], " " * (8 - len(pkg_repo[2])), pkg_repo[3], " " * (7 - len(pkg_repo[3])), "Slack", size, " K")).rstrip()
def data(self): """Check all installed packages and create dictionary database """ for pkg in self.installed: if os.path.isfile(self.meta.pkg_path + pkg): name = split_package(pkg)[0] for log in self.logs: deps = Utils().read_file(self.dep_path + log) for dep in deps.splitlines(): if name == dep: if name not in self.dmap.keys(): self.dmap[name] = [log] if not self.count_pkg: self.count_pkg = 1 else: self.dmap[name] += [log] self.count_packages()
def views(install_all, comp_sum): ''' Views packages ''' pkg_sum = uni_sum = upg_sum = 0 for pkg, comp in zip(install_all, comp_sum): pkg_split = split_package(pkg[:-4]) if os.path.isfile(pkg_path + pkg[:-4]): pkg_sum += 1 COLOR = GREEN elif find_package(pkg_split[0] + "-", pkg_path): COLOR = YELLOW upg_sum += 1 else: COLOR = RED uni_sum += 1 print(" {0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11:>12}{12}".format( COLOR, pkg_split[0], ENDC, " " * (25 - len(pkg_split[0])), pkg_split[1], " " * (19 - len(pkg_split[1])), pkg_split[2], " " * (8 - len(pkg_split[2])), pkg_split[3], " " * (7 - len(pkg_split[3])), "Slack", comp, " K")) return [pkg_sum, upg_sum, uni_sum]
def store(self): """ Store and return packages for upgrading """ data = repo_data(self.PACKAGES_TXT, "slack", self.flag) black = BlackList().packages(pkgs=data[0], repo="slack") for name, loc, comp, uncomp in zip(data[0], data[1], data[2], data[3]): status(0.0003) repo_pkg_name = split_package(name)[0] if (not os.path.isfile(self.meta.pkg_path + name[:-4]) and repo_pkg_name not in black and repo_pkg_name not in self.skip): self.dwn_links.append("{0}{1}/{2}".format( mirrors("", ""), loc, name)) self.comp_sum.append(comp) self.uncomp_sum.append(uncomp) self.upgrade_all.append(name) self.count_upg += 1 if not find_package(repo_pkg_name + self.meta.sp, self.meta.pkg_path): self.count_added += 1 self.count_upg -= 1 return self.count_upg
def get_deps(self): """Grap package requirements from repositories """ if self.repo == "rlw": dependencies = {} rlw_deps = Utils().read_file(_meta_.conf_path + "rlworkman.deps") for line in rlw_deps.splitlines(): if line and not line.startswith("#"): pkgs = line.split(":") dependencies[pkgs[0]] = pkgs[1] if self.name in dependencies.keys(): return dependencies[self.name].split() else: return "" else: PACKAGES_TXT = Utils().read_file("{0}{1}_repo/PACKAGES.TXT".format( _meta_.lib_path, self.repo)) for line in PACKAGES_TXT.splitlines(): if line.startswith("PACKAGE NAME:"): pkg_name = split_package(line[14:].strip())[0] if line.startswith("PACKAGE REQUIRED:"): if pkg_name == self.name: if line[18:].strip(): return self._req_fix(line)
def version(self): """Return version from installed packages """ if self.find: return self.meta.sp + split_package(self.find)[1] return ""