From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from pigeon.gentoo.org ([208.92.234.80] helo=lists.gentoo.org) by finch.gentoo.org with esmtp (Exim 4.60) (envelope-from ) id 1Qmp2E-00012K-QU for garchives@archives.gentoo.org; Fri, 29 Jul 2011 15:31:35 +0000 Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 6F85621C25A; Fri, 29 Jul 2011 15:31:16 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) by pigeon.gentoo.org (Postfix) with ESMTP id F17AD21C25A for ; Fri, 29 Jul 2011 15:31:15 +0000 (UTC) Received: from pelican.gentoo.org (unknown [66.219.59.40]) (using TLSv1 with cipher ADH-AES256-SHA (256/256 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 62C6B1B401A for ; Fri, 29 Jul 2011 15:31:15 +0000 (UTC) Received: from localhost.localdomain (localhost [127.0.0.1]) by pelican.gentoo.org (Postfix) with ESMTP id 7F61480042 for ; Fri, 29 Jul 2011 15:31:14 +0000 (UTC) From: "Magnus Granberg" To: gentoo-commits@lists.gentoo.org Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Magnus Granberg" Message-ID: <8554eeee41909a2df43989d6872346b5b64e4570.zorry@gentoo> Subject: [gentoo-commits] dev/zorry:master commit in: gobs/pym/ X-VCS-Repository: dev/zorry X-VCS-Files: gobs/pym/ConnectionManager.py gobs/pym/build_log.py gobs/pym/build_queru.py gobs/pym/depclean.py gobs/pym/flags.py gobs/pym/old_cpv.py gobs/pym/package.py gobs/pym/text.py X-VCS-Directories: gobs/pym/ X-VCS-Committer: zorry X-VCS-Committer-Name: Magnus Granberg X-VCS-Revision: 8554eeee41909a2df43989d6872346b5b64e4570 Date: Fri, 29 Jul 2011 15:31:14 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: quoted-printable X-Archives-Salt: X-Archives-Hash: 90894c04cbf0e7b1f1ff6de64555b50f commit: 8554eeee41909a2df43989d6872346b5b64e4570 Author: Magnus Granberg gentoo org> AuthorDate: Fri Jul 29 15:29:35 2011 +0000 Commit: Magnus Granberg gentoo org> CommitDate: Fri Jul 29 15:29:35 2011 +0000 URL: http://git.overlays.gentoo.org/gitweb/?p=3Ddev/zorry.git;a=3D= commit;h=3D8554eeee Updated alot in the pym dir --- gobs/pym/ConnectionManager.py | 26 +- gobs/pym/build_log.py | 99 ++++--- gobs/pym/build_queru.py | 158 ++++++++++ gobs/pym/depclean.py | 632 +++++++++++++++++++++++++++++++++++= ++++++ gobs/pym/flags.py | 27 +- gobs/pym/old_cpv.py | 11 +- gobs/pym/package.py | 44 +--- gobs/pym/text.py | 19 +- 8 files changed, 901 insertions(+), 115 deletions(-) diff --git a/gobs/pym/ConnectionManager.py b/gobs/pym/ConnectionManager.p= y index 7d87702..1bbeb35 100644 --- a/gobs/pym/ConnectionManager.py +++ b/gobs/pym/ConnectionManager.py @@ -1,31 +1,31 @@ #a simple CM build around sie singleton so there can only be 1 CM but yo= u can call the class in different place with out caring about it. #when the first object is created of this class, the SQL settings are re= ad from the file and stored in the class for later reuse by the next obje= ct and so on. #(maybe later add support for connection pools) +from __future__ import print_function + class connectionManager(object): _instance =3D None =20 =20 - #size of the connection Pool + #size of the connection Pool def __new__(cls, settings_dict, numberOfconnections=3D20, *args, **k= wargs): if not cls._instance: cls._instance =3D super(connectionManager, cls).__new__(cls,= *args, **kwargs) #read the sql user/host etc and store it in the local object - print settings_dict['sql_host'] + print(settings_dict['sql_host']) cls._host=3Dsettings_dict['sql_host'] cls._user=3Dsettings_dict['sql_user'] cls._password=3Dsettings_dict['sql_passwd'] cls._database=3Dsettings_dict['sql_db'] #shouldnt we include port also? try: - from psycopg2 import pool - cls._connectionNumber=3DnumberOfconnections - #always create 1 connection - cls._pool=3Dpool.ThreadedConnectionPool(1,cls._connectionNumber,h= ost=3Dcls._host,database=3Dcls._database,user=3Dcls._user,password=3Dcls.= _password) - cls._name=3D'pgsql' - =20 - =20 - except ImportError: - print "Please install a recent version of dev-python/psycopg for = Python" - sys.exit(1) + from psycopg2 import pool + cls._connectionNumber=3DnumberOfconnections + #always create 1 connection + cls._pool=3Dpool.ThreadedConnectionPool(1,cls._connectionN= umber,host=3Dcls._host,database=3Dcls._database,user=3Dcls._user,password= =3Dcls._password) + cls._name=3D'pgsql' + except ImportError: + print("Please install a recent version of dev-python/psyco= pg for Python") + sys.exit(1) #setup connection pool return cls._instance =20 @@ -38,7 +38,7 @@ class connectionManager(object): =20 def putConnection(self, connection): self._pool.putconn(connection) -=09 + def closeAllConnections(self): self._pool.closeall() =20 diff --git a/gobs/pym/build_log.py b/gobs/pym/build_log.py index 4f5a801..eb5fcea 100644 --- a/gobs/pym/build_log.py +++ b/gobs/pym/build_log.py @@ -1,8 +1,10 @@ +from __future__ import print_function import re from gobs.text import get_log_text_list from gobs.repoman_gobs import gobs_repoman import portage from gobs.readconf import get_conf_settings +from gobs.flags import gobs_use_flags reader=3Dget_conf_settings() gobs_settings_dict=3Dreader.read_gobs_settings_all() # make a CM @@ -16,35 +18,58 @@ elif CM.getName()=3D=3D'mysql': =20 class gobs_buildlog(object): =09 - def __init__(self, CM, mysettings, build_dict, config_profile): + def __init__(self, mysettings, build_dict): self._mysettings =3D mysettings self._myportdb =3D portage.portdbapi(mysettings=3Dself._mysettings) self._build_dict =3D build_dict - self._config_profile =3D config_profile - self._CM =3D CM self._logfile_text =3D get_log_text_list(self._mysettings.get("PORTAGE= _LOG_FILE")) +=09 + def add_new_ebuild_buildlog(self, build_error, summary_error, build_log= _dict): + conn=3DCM.getConnection() + cpv =3D self._build_dict['cpv'] + init_useflags =3D gobs_use_flags(self._mysettings, self._myportdb, cpv= ) + iuse_flags_list, final_use_list =3D init_useflags.get_flags_looked() + iuse =3D [] + use_flags_list =3D [] + use_enable_list =3D [] + for iuse_line in iuse_flags_list: + iuse.append(init_useflags.reduce_flag(iuse_line)) + iuse_flags_list2 =3D list(set(iuse)) + use_enable =3D final_use_list + use_disable =3D list(set(iuse_flags_list2).difference(set(use_enable))= ) + use_flagsDict =3D {} + for x in use_enable: + use_flagsDict[x] =3D True + for x in use_disable: + use_flagsDict[x] =3D False + for u, s in use_flagsDict.iteritems(): + use_flags_list.append(u) + use_enable_list.append(s) + build_id =3D add_new_buildlog(conn, self._build_dict, use_flags_list, = use_enable_list, build_error, summary_error, build_log_dict) + CM.putConnection(conn) + return build_id =20 - def search_info(self, textline, error_log_list, i): + def search_info(self, textline, error_log_list): if re.search(" * Package:", textline): - print 'Package' + print('Package') error_log_list.append(textline) if re.search(" * Repository:", textline): - print 'Repository' + print('Repository') error_log_list.append(textline) if re.search(" * Maintainer:", textline): error_log_list.append(textline) - print 'Maintainer' + print('Maintainer') if re.search(" * USE:", textline): error_log_list.append(textline) - print 'USE' + print('USE') if re.search(" * FEATURES:", textline): error_log_list.append(textline) - print 'FEATURES' + print('FEATURES') return error_log_list =20 def search_error(self, textline, error_log_list, sum_build_log_list, i)= : if re.search("Error 1", textline): - print 'Error' + print('Error') x =3D i - 20 endline =3D True error_log_list.append(".....\n") @@ -56,7 +81,7 @@ class gobs_buildlog(object): else: x =3D x +1 if re.search(" * ERROR:", textline): - print 'ERROR' + print('ERROR') x =3D i endline=3D True field =3D textline.split(" ") @@ -69,12 +94,25 @@ class gobs_buildlog(object): endline =3D False else: x =3D x +1 + if re.search("configure: error:", textline): + print('configure: error:') + x =3D i - 4 + endline =3D True + error_log_list.append(".....\n") + while x !=3D i + 3 and endline: + try: + error_log_list.append(self._logfile_text[x]) + except: + endline =3D False + else: + x =3D x +1 return error_log_list, sum_build_log_list =20 def search_qa(self, textline, qa_error_list, error_log_list,i): - if re.search(" * QA Notice: Package has poor programming", textline): - print 'QA Notice' + if re.search(" * QA Notice:", textline): + print('QA Notice') x =3D i + qa_error_list.append(self._logfile_text[x]) endline=3D True error_log_list.append(".....\n") while x !=3D i + 3 and endline: @@ -84,20 +122,6 @@ class gobs_buildlog(object): endline =3D False else: x =3D x +1 - qa_error_list.append('QA Notice: Package has poor programming practic= es') - if re.search(" * QA Notice: The following shared libraries lack NEEDE= D", textline): - print 'QA Notice' - x =3D i - endline=3D True - error_log_list.append(".....\n") - while x !=3D i + 2 and endline: - try: - error_log_list.append(self._logfile_text[x]) - except: - endline =3D False - else: - x =3D x +1 - qa_error_list.append('QA Notice: The following shared libraries lack= NEEDED entries') return qa_error_list, error_log_list =20 def get_buildlog_info(self): @@ -110,15 +134,12 @@ class gobs_buildlog(object): repoman_error_list =3D [] sum_build_log_list =3D [] for textline in self._logfile_text: - error_log_list =3D self.search_info(textline, error_log_list, i) + error_log_list =3D self.search_info(textline, error_log_list) error_log_list, sum_build_log_list =3D self.search_error(textline, er= ror_log_list, sum_build_log_list, i) qa_error_list, error_log_list =3D self.search_qa(textline, qa_error_l= ist, error_log_list, i) i =3D i +1 # Run repoman check_repoman() - categories =3D self._build_dict['categories'] - package =3D self._build_dict['package'] - ebuild_version =3D self._build_dict['ebuild_version'] - repoman_error_list =3D init_repoman.check_repoman(categories, package,= ebuild_version, self._config_profile) + repoman_error_list =3D init_repoman.check_repoman(self._build_dict['ca= tegories'], self._build_dict['package'], self._build_dict['ebuild_version= '], self._build_dict['config_profile']) if repoman_error_list !=3D []: sum_build_log_list.append("repoman") if qa_error_list !=3D []: @@ -130,7 +151,7 @@ class gobs_buildlog(object): return build_log_dict =20 def add_buildlog_main(self): - conn=3Dself._CM.getConnection() + conn=3DCM.getConnection() build_log_dict =3D {} build_log_dict =3D self.get_buildlog_info() sum_build_log_list =3D build_log_dict['summary_error_list'] @@ -143,8 +164,12 @@ class gobs_buildlog(object): if sum_build_log_list !=3D []: for sum_log_line in sum_build_log_list: summary_error =3D summary_error + " " + sum_log_line - print 'summary_error', summary_error - logfilename =3D re.sub("\/var\/log\/portage\/", "", self._mysettings.= get("PORTAGE_LOG_FILE")) - build_id =3D move_queru_buildlog(conn, self._build_dict['queue_id'], b= uild_error, summary_error, logfilename, build_log_dict) + print('summary_error', summary_error) + build_log_dict['logfilename'] =3D re.sub("\/var\/log\/portage\/", "", = self._mysettings.get("PORTAGE_LOG_FILE")) + print(self._build_dict['queue_id'], build_error, summary_error, build_= log_dict['logfilename'], build_log_dict) + if self._build_dict['queue_id'] is None: + build_id =3D self.add_new_ebuild_buildlog(build_error, summary_error,= build_log_dict) + else: + build_id =3D move_queru_buildlog(conn, self._build_dict['queue_id'], = build_error, summary_error, build_log_dict) # update_qa_repoman(conn, build_id, build_log_dict) - print "build_id", build_id, "logged to db." + print("build_id", build_id[0], "logged to db.") diff --git a/gobs/pym/build_queru.py b/gobs/pym/build_queru.py new file mode 100644 index 0000000..3d53a05 --- /dev/null +++ b/gobs/pym/build_queru.py @@ -0,0 +1,158 @@ +# Get the options from the config file set in gobs.readconf +from gobs.readconf import get_conf_settings +reader=3Dget_conf_settings() +gobs_settings_dict=3Dreader.read_gobs_settings_all() +# make a CM +from gobs.ConnectionManager import connectionManager +CM=3DconnectionManager(gobs_settings_dict) +#selectively import the pgsql/mysql querys +if CM.getName()=3D=3D'pgsql': + from gobs.querys.pgsql import * +elif CM.getName()=3D=3D'mysql': + from gobs.querys.mysql import * + +import portage +import os +from gobs.manifest import gobs_manifest +from gobs.depclean import main_depclean +from gobs.flags import gobs_use_flags +from _emerge.main import emerge_main + +class queruaction(object): + + def __init__(self, config_profile): + self._mysettings =3D portage.settings + self._config_profile =3D config_profile + self._myportdb =3D portage.portdb + + def log_fail_queru(self, build_dict, fail_querue_dict): + fail_times =3D 0 + if fail_querue_dict =3D=3D {}: + attDict =3D {} + attDict[build_dict['type_fail']] =3D 1 + attDict['build_info'] =3D build_dict + fail_querue_dict[build_dict['querue_id']] =3D attDict + return fail_querue_dict + else: + # FIXME:If is 5 remove fail_querue_dict[build_dict['querue_id'] from= =20 + # fail_querue_dict and add log to db. + if not fail_querue_dict[build_dict['querue_id']] is None: + if fail_querue_dict[build_dict['querue_id']][build_dict['type_fail']= ] is None: + fail_querue_dict[build_dict['querue_id']][build_dict['type_fail']] = =3D 1 + return fail_querue_dict + else: + fail_times =3D fail_querue_dict[build_dict['querue_id']][build_dict= ['type_fail']] + fail_times =3D fail_times + 1 + if not fail_times is 5: + fail_querue_dict[build_dict['querue_id']][build_dict['type_fail']]= =3D fail_times + return fail_querue_dict + else: + # FIXME:If is 5 remove fail_querue_dict[build_dict['querue_id']] = from + # fail_querue_dict and add log to db. + return fail_querue_dict + else: + attDict =3D {} + attDict[build_dict['type_fail']] =3D 1 + attDict['build_info'] =3D build_dict + fail_querue_dict[build_dict['querue_id']] =3D attDict + return fail_querue_dict + + def make_build_list(self, build_dict): + conn=3DCM.getConnection() + cpv =3D build_dict['category']+'/'+build_dict['package']+'-'+build_dic= t['ebuild_version'] + pkgdir =3D os.path.join(self._mysettings['PORTDIR'], build_dict['categ= ory'] + "/" + build_dict['package']) + init_manifest =3D gobs_manifest(self._mysettings, pkgdir) + try: + ebuild_version_checksum_tree =3D portage.checksum.sha256hash(pkgdir+ = "/" + build_dict['package'] + "-" + build_dict['ebuild_version'] + ".ebui= ld")[0] + except: + ebuild_version_checksum_tree =3D None + if ebuild_version_checksum_tree =3D=3D build_dict['checksum']: + if portage.getmaskingstatus(cpv, settings=3Dself._mysettings, portdb=3D= self._myportdb) =3D=3D []: + init_flags =3D gobs_use_flags(self._mysettings, self._myportdb, cpv) + build_use_flags_list =3D init_flags.comper_useflags(build_dict) + print "build_use_flags_list", build_use_flags_list + manifest_error =3D init_manifest.check_file_in_manifest(self._myport= db, cpv, build_dict, build_use_flags_list) + if manifest_error is None: + build_dict['check_fail'] =3D False + build_cpv_dict =3D init_flags.get_needed_dep_useflags(build_use_fla= gs_list) + print build_cpv_dict, build_use_flags_list, cpv + build_use_flags_dict =3D {} + if build_use_flags_list is None: + build_use_flags_dict['None'] =3D None + if build_cpv_dict is None: + build_cpv_dict =3D {} + build_cpv_dict[cpv] =3D build_use_flags_dict + else: + build_cpv_dict[cpv] =3D build_use_flags_dict + print build_cpv_dict + return build_cpv_dict, build_dict + else: + build_dict['1'] =3D 1 + else: + build_dict['2'] =3D 2 + else: + build_dict['3'] =3D 3 + build_dict['check_fail'] =3D True + return build_cpv_dict, build_dict + + def build_procces(self, buildqueru_cpv_dict, build_dict): + build_cpv_list =3D [] + for k, v in buildqueru_cpv_dict.iteritems(): + build_use_flags_list =3D [] + for x, y in v.iteritems(): + if y is True: + build_use_flags_list.append(x) + if y is False: + build_use_flags_list.append("-" + x) + print k, build_use_flags_list + if build_use_flags_list =3D=3D []: + build_cpv_list.append("=3D" + k) + else: + build_use_flags =3D "" + for flags in build_use_flags_list: + build_use_flags =3D build_use_flags + flags + "," + build_cpv_list.append("=3D" + k + "[" + build_use_flags + "]") + print 'build_cpv_list', build_cpv_list + argscmd =3D [] + if not "nooneshort" in build_dict['post_message']: + argscmd.append("--oneshot") + argscmd.append("--buildpkg") + argscmd.append("--usepkg") + for build_cpv in build_cpv_list: + argscmd.append(build_cpv) + print argscmd + # Call main_emerge to build the package in build_cpv_list=20 + try:=20 + build_fail =3D emerge_main(args=3Dargscmd) + except: + build_fail =3D False + # Run depclean + if not "nodepclean" in build_dict['post_message']: + depclean_fail =3D main_depclean() + if build_fail is False or depclean_fail is False: + return False + return True + + def procces_qureru(self, fail_querue_dict): + conn=3DCM.getConnection() + build_dict =3D {} + build_dict =3D get_packages_to_build(conn, self._config_profile) + print "build_dict", build_dict + if build_dict is None and fail_querue_dict =3D=3D {}: + return fail_querue_dict + if build_dict is None and fail_querue_dict !=3D {}: + return fail_querue_dict + if not build_dict['ebuild_id'] is None and build_dict['checksum'] is n= ot None: + buildqueru_cpv_dict, build_dict =3D self.make_build_list(build_dict) + print 'buildqueru_cpv_dict', buildqueru_cpv_dict + if buildqueru_cpv_dict is None: + return fail_querue_dict + fail_build_procces =3D self.build_procces(buildqueru_cpv_dict, build_= dict) + if build_dict['check_fail'] is True: + fail_querue_dict =3D self.log_fail_queru(build_dict, fail_querue_dic= t) + return fail_querue_dict + if not build_dict['post_message'] is [] and build_dict['ebuild_id'] is= None: + return fail_querue_dict + if not build_dict['ebuild_id'] is None and build_dict['checksum'] is N= one: + del_old_queue(conn, build_dict['queue_id']) + return fail_querue_dict diff --git a/gobs/pym/depclean.py b/gobs/pym/depclean.py new file mode 100644 index 0000000..b6096b6 --- /dev/null +++ b/gobs/pym/depclean.py @@ -0,0 +1,632 @@ +from __future__ import print_function +import errno +import portage +from portage._sets.base import InternalPackageSet +from _emerge.main import parse_opts +from _emerge.create_depgraph_params import create_depgraph_params +from _emerge.depgraph import backtrack_depgraph, depgraph, resume_depgra= ph +from _emerge.UnmergeDepPriority import UnmergeDepPriority +from _emerge.SetArg import SetArg +from _emerge.actions import load_emerge_config +from _emerge.Package import Package +from _emerge.unmerge import unmerge +from portage.util import cmp_sort_key, writemsg, \ + writemsg_level, writemsg_stdout +from portage.util.digraph import digraph + +def main_depclean(): + mysettings, mytrees, mtimedb =3D load_emerge_config() + myroot =3D mysettings["ROOT"] + root_config =3D mytrees[myroot]["root_config"] + psets =3D root_config.setconfig.psets + args_set =3D InternalPackageSet(allow_repo=3DTrue) + spinner=3DNone + scheduler=3DNone + tmpcmdline =3D [] + tmpcmdline.append("--depclean") + tmpcmdline.append("--pretend") + print("depclean",tmpcmdline) + myaction, myopts, myfiles =3D parse_opts(tmpcmdline, silent=3DFalse) + if myfiles: + args_set.update(myfiles) + matched_packages =3D False + for x in args_set: + if vardb.match(x): + matched_packages =3D True + if not matched_packages: + return 0 + + rval, cleanlist, ordered, req_pkg_count, unresolvable =3D calc_depclean= (mysettings, mytrees, mtimedb["ldpath"], myopts, myaction, args_set, spin= ner) + print('rval, cleanlist, ordered, req_pkg_count, unresolvable', rval, cl= eanlist, ordered, req_pkg_count, unresolvable) + if unresolvable !=3D []: + return True + if cleanlist !=3D []: + conflict_package_list =3D [] + for depclean_cpv in cleanlist: + if portage.versions.cpv_getkey(depclean_cpv) in list(psets["system"])= : + conflict_package_list.append(depclean_cpv) + if portage.versions.cpv_getkey(depclean_cpv) in list(psets['selected'= ]): + conflict_package_list.append(depclean_cpv) + print('conflict_package_list', conflict_package_list) + if conflict_package_list =3D=3D []: + tmpcmdline =3D [] + tmpcmdline.append("--depclean") + myaction, myopts, myfiles =3D parse_opts(tmpcmdline, silent=3DFalse) + unmerge(root_config, myopts, "unmerge", cleanlist, mtimedb["ldpath"],= ordered=3Dordered, scheduler=3Dscheduler) + print("Number removed: "+str(len(cleanlist))) + return True + return True + +def calc_depclean(settings, trees, ldpath_mtimes, + myopts, action, args_set, spinner): + allow_missing_deps =3D bool(args_set) + + debug =3D '--debug' in myopts + xterm_titles =3D "notitles" not in settings.features + myroot =3D settings["ROOT"] + root_config =3D trees[myroot]["root_config"] + psets =3D root_config.setconfig.psets + deselect =3D myopts.get('--deselect') !=3D 'n' + required_sets =3D {} + required_sets['world'] =3D psets['world'] + + # When removing packages, a temporary version of the world 'selected' + # set may be used which excludes packages that are intended to be + # eligible for removal. + selected_set =3D psets['selected'] + required_sets['selected'] =3D selected_set + protected_set =3D InternalPackageSet() + protected_set_name =3D '____depclean_protected_set____' + required_sets[protected_set_name] =3D protected_set + system_set =3D psets["system"] + + if not system_set or not selected_set: + + if not system_set: + writemsg_level("!!! You have no system list.\n", + level=3Dlogging.ERROR, noiselevel=3D-1) + + if not selected_set: + writemsg_level("!!! You have no world file.\n", + level=3Dlogging.WARNING, noiselevel=3D-1) + + writemsg_level("!!! Proceeding is likely to " + \ + "break your installation.\n", + level=3Dlogging.WARNING, noiselevel=3D-1) + if "--pretend" not in myopts: + countdown(int(settings["EMERGE_WARNING_DELAY"]), ">>> Depclean") + + if action =3D=3D "depclean": + print(" >>> depclean") + + writemsg_level("\nCalculating dependencies ") + resolver_params =3D create_depgraph_params(myopts, "remove") + resolver =3D depgraph(settings, trees, myopts, resolver_params, spinner= ) + resolver._load_vdb() + vardb =3D resolver._frozen_config.trees[myroot]["vartree"].dbapi + real_vardb =3D trees[myroot]["vartree"].dbapi + + if action =3D=3D "depclean": + + if args_set: + + if deselect: + # Start with an empty set. + selected_set =3D InternalPackageSet() + required_sets['selected'] =3D selected_set + # Pull in any sets nested within the selected set. + selected_set.update(psets['selected'].getNonAtoms()) + + # Pull in everything that's installed but not matched + # by an argument atom since we don't want to clean any + # package if something depends on it. + for pkg in vardb: + if spinner: + spinner.update() + + try: + if args_set.findAtomForPackage(pkg) is None: + protected_set.add("=3D" + pkg.cpv) + continue + except portage.exception.InvalidDependString as e: + show_invalid_depstring_notice(pkg, + pkg.metadata["PROVIDE"], str(e)) + del e + protected_set.add("=3D" + pkg.cpv) + continue + + elif action =3D=3D "prune": + + if deselect: + # Start with an empty set. + selected_set =3D InternalPackageSet() + required_sets['selected'] =3D selected_set + # Pull in any sets nested within the selected set. + selected_set.update(psets['selected'].getNonAtoms()) + + # Pull in everything that's installed since we don't + # to prune a package if something depends on it. + protected_set.update(vardb.cp_all()) + + if not args_set: + + # Try to prune everything that's slotted. + for cp in vardb.cp_all(): + if len(vardb.cp_list(cp)) > 1: + args_set.add(cp) + + # Remove atoms from world that match installed packages + # that are also matched by argument atoms, but do not remove + # them if they match the highest installed version. + for pkg in vardb: + spinner.update() + pkgs_for_cp =3D vardb.match_pkgs(pkg.cp) + if not pkgs_for_cp or pkg not in pkgs_for_cp: + raise AssertionError("package expected in matches: " + \ + "cp =3D %s, cpv =3D %s matches =3D %s" % \ + (pkg.cp, pkg.cpv, [str(x) for x in pkgs_for_cp])) + + highest_version =3D pkgs_for_cp[-1] + if pkg =3D=3D highest_version: + # pkg is the highest version + protected_set.add("=3D" + pkg.cpv) + continue + + if len(pkgs_for_cp) <=3D 1: + raise AssertionError("more packages expected: " + \ + "cp =3D %s, cpv =3D %s matches =3D %s" % \ + (pkg.cp, pkg.cpv, [str(x) for x in pkgs_for_cp])) + + try: + if args_set.findAtomForPackage(pkg) is None: + protected_set.add("=3D" + pkg.cpv) + continue + except portage.exception.InvalidDependString as e: + show_invalid_depstring_notice(pkg, + pkg.metadata["PROVIDE"], str(e)) + del e + protected_set.add("=3D" + pkg.cpv) + continue + + if resolver._frozen_config.excluded_pkgs: + excluded_set =3D resolver._frozen_config.excluded_pkgs + required_sets['__excluded__'] =3D InternalPackageSet() + + for pkg in vardb: + if spinner: + spinner.update() + + try: + if excluded_set.findAtomForPackage(pkg): + required_sets['__excluded__'].add("=3D" + pkg.cpv) + except portage.exception.InvalidDependString as e: + show_invalid_depstring_notice(pkg, + pkg.metadata["PROVIDE"], str(e)) + del e + required_sets['__excluded__'].add("=3D" + pkg.cpv) + + success =3D resolver._complete_graph(required_sets=3D{myroot:required_s= ets}) + writemsg_level("\b\b... done!\n") + + resolver.display_problems() + + if not success: + return True, [], False, 0, [] + + def unresolved_deps(): + + unresolvable =3D set() + for dep in resolver._dynamic_config._initially_unsatisfied_deps: + if isinstance(dep.parent, Package) and \ + (dep.priority > UnmergeDepPriority.SOFT): + unresolvable.add((dep.atom, dep.parent.cpv)) + + if not unresolvable: + return None + + if unresolvable and not allow_missing_deps: + + prefix =3D bad(" * ") + msg =3D [] + msg.append("Dependencies could not be completely resolved due to") + msg.append("the following required packages not being installed:") + msg.append("") + for atom, parent in unresolvable: + msg.append(" %s pulled in by:" % (atom,)) + msg.append(" %s" % (parent,)) + msg.append("") + msg.extend(textwrap.wrap( + "Have you forgotten to do a complete update prior " + \ + "to depclean? The most comprehensive command for this " + \ + "purpose is as follows:", 65 + )) + msg.append("") + msg.append(" " + \ + good("emerge --update --newuse --deep --with-bdeps=3Dy @world")) + msg.append("") + msg.extend(textwrap.wrap( + "Note that the --with-bdeps=3Dy option is not required in " + \ + "many situations. Refer to the emerge manual page " + \ + "(run `man emerge`) for more information about " + \ + "--with-bdeps.", 65 + )) + msg.append("") + msg.extend(textwrap.wrap( + "Also, note that it may be necessary to manually uninstall " + \ + "packages that no longer exist in the portage tree, since " + \ + "it may not be possible to satisfy their dependencies.", 65 + )) + if action =3D=3D "prune": + msg.append("") + msg.append("If you would like to ignore " + \ + "dependencies then use %s." % good("--nodeps")) + writemsg_level("".join("%s%s\n" % (prefix, line) for line in msg), + level=3Dlogging.ERROR, noiselevel=3D-1) + return unresolvable + return None + + unresolvable =3D unresolved_deps() + if not unresolvable is None: + return False, [], False, 0, unresolvable + + graph =3D resolver._dynamic_config.digraph.copy() + required_pkgs_total =3D 0 + for node in graph: + if isinstance(node, Package): + required_pkgs_total +=3D 1 + + def show_parents(child_node): + parent_nodes =3D graph.parent_nodes(child_node) + if not parent_nodes: + # With --prune, the highest version can be pulled in without any + # real parent since all installed packages are pulled in. In that + # case there's nothing to show here. + return + parent_strs =3D [] + for node in parent_nodes: + parent_strs.append(str(getattr(node, "cpv", node))) + parent_strs.sort() + msg =3D [] + msg.append(" %s pulled in by:\n" % (child_node.cpv,)) + for parent_str in parent_strs: + msg.append(" %s\n" % (parent_str,)) + msg.append("\n") + portage.writemsg_stdout("".join(msg), noiselevel=3D-1) + + def cmp_pkg_cpv(pkg1, pkg2): + """Sort Package instances by cpv.""" + if pkg1.cpv > pkg2.cpv: + return 1 + elif pkg1.cpv =3D=3D pkg2.cpv: + return 0 + else: + return -1 + + def create_cleanlist(): + + # Never display the special internal protected_set. + for node in graph: + if isinstance(node, SetArg) and node.name =3D=3D protected_set_name: + graph.remove(node) + break + + pkgs_to_remove =3D [] + + if action =3D=3D "depclean": + if args_set: + + for pkg in sorted(vardb, key=3Dcmp_sort_key(cmp_pkg_cpv)): + arg_atom =3D None + try: + arg_atom =3D args_set.findAtomForPackage(pkg) + except portage.exception.InvalidDependString: + # this error has already been displayed by now + continue + + if arg_atom: + if pkg not in graph: + pkgs_to_remove.append(pkg) + elif "--verbose" in myopts: + show_parents(pkg) + + else: + for pkg in sorted(vardb, key=3Dcmp_sort_key(cmp_pkg_cpv)): + if pkg not in graph: + pkgs_to_remove.append(pkg) + elif "--verbose" in myopts: + show_parents(pkg) + + elif action =3D=3D "prune": + + for atom in args_set: + for pkg in vardb.match_pkgs(atom): + if pkg not in graph: + pkgs_to_remove.append(pkg) + elif "--verbose" in myopts: + show_parents(pkg) + + return pkgs_to_remove + + cleanlist =3D create_cleanlist() + clean_set =3D set(cleanlist) + + if cleanlist and \ + real_vardb._linkmap is not None and \ + myopts.get("--depclean-lib-check") !=3D "n" and \ + "preserve-libs" not in settings.features: + + # Check if any of these packages are the sole providers of libraries + # with consumers that have not been selected for removal. If so, these + # packages and any dependencies need to be added to the graph. + linkmap =3D real_vardb._linkmap + consumer_cache =3D {} + provider_cache =3D {} + consumer_map =3D {} + + writemsg_level(">>> Checking for lib consumers...\n") + + for pkg in cleanlist: + pkg_dblink =3D real_vardb._dblink(pkg.cpv) + consumers =3D {} + + for lib in pkg_dblink.getcontents(): + lib =3D lib[len(myroot):] + lib_key =3D linkmap._obj_key(lib) + lib_consumers =3D consumer_cache.get(lib_key) + if lib_consumers is None: + try: + lib_consumers =3D linkmap.findConsumers(lib_key) + except KeyError: + continue + consumer_cache[lib_key] =3D lib_consumers + if lib_consumers: + consumers[lib_key] =3D lib_consumers + + if not consumers: + continue + + for lib, lib_consumers in list(consumers.items()): + for consumer_file in list(lib_consumers): + if pkg_dblink.isowner(consumer_file): + lib_consumers.remove(consumer_file) + if not lib_consumers: + del consumers[lib] + + if not consumers: + continue + + for lib, lib_consumers in consumers.items(): + + soname =3D linkmap.getSoname(lib) + + consumer_providers =3D [] + for lib_consumer in lib_consumers: + providers =3D provider_cache.get(lib) + if providers is None: + providers =3D linkmap.findProviders(lib_consumer) + provider_cache[lib_consumer] =3D providers + if soname not in providers: + # Why does this happen? + continue + consumer_providers.append( + (lib_consumer, providers[soname])) + + consumers[lib] =3D consumer_providers + + consumer_map[pkg] =3D consumers + + if consumer_map: + + search_files =3D set() + for consumers in consumer_map.values(): + for lib, consumer_providers in consumers.items(): + for lib_consumer, providers in consumer_providers: + search_files.add(lib_consumer) + search_files.update(providers) + + writemsg_level(">>> Assigning files to packages...\n") + file_owners =3D real_vardb._owners.getFileOwnerMap(search_files) + + for pkg, consumers in list(consumer_map.items()): + for lib, consumer_providers in list(consumers.items()): + lib_consumers =3D set() + + for lib_consumer, providers in consumer_providers: + owner_set =3D file_owners.get(lib_consumer) + provider_dblinks =3D set() + provider_pkgs =3D set() + + if len(providers) > 1: + for provider in providers: + provider_set =3D file_owners.get(provider) + if provider_set is not None: + provider_dblinks.update(provider_set) + + if len(provider_dblinks) > 1: + for provider_dblink in provider_dblinks: + provider_pkg =3D resolver._pkg( + provider_dblink.mycpv, "installed", + root_config, installed=3DTrue) + if provider_pkg not in clean_set: + provider_pkgs.add(provider_pkg) + + if provider_pkgs: + continue + + if owner_set is not None: + lib_consumers.update(owner_set) + + for consumer_dblink in list(lib_consumers): + if resolver._pkg(consumer_dblink.mycpv, "installed", + root_config, installed=3DTrue) in clean_set: + lib_consumers.remove(consumer_dblink) + continue + + if lib_consumers: + consumers[lib] =3D lib_consumers + else: + del consumers[lib] + if not consumers: + del consumer_map[pkg] + + if consumer_map: + # TODO: Implement a package set for rebuilding consumer packages. + + msg =3D "In order to avoid breakage of link level " + \ + "dependencies, one or more packages will not be removed. " + \ + "This can be solved by rebuilding " + \ + "the packages that pulled them in." + + prefix =3D bad(" * ") + from textwrap import wrap + writemsg_level("".join(prefix + "%s\n" % line for \ + line in wrap(msg, 70)), level=3Dlogging.WARNING, noiselevel=3D-1) + + msg =3D [] + for pkg in sorted(consumer_map, key=3Dcmp_sort_key(cmp_pkg_cpv)): + consumers =3D consumer_map[pkg] + consumer_libs =3D {} + for lib, lib_consumers in consumers.items(): + for consumer in lib_consumers: + consumer_libs.setdefault( + consumer.mycpv, set()).add(linkmap.getSoname(lib)) + unique_consumers =3D set(chain(*consumers.values())) + unique_consumers =3D sorted(consumer.mycpv \ + for consumer in unique_consumers) + msg.append("") + msg.append(" %s pulled in by:" % (pkg.cpv,)) + for consumer in unique_consumers: + libs =3D consumer_libs[consumer] + msg.append(" %s needs %s" % \ + (consumer, ', '.join(sorted(libs)))) + msg.append("") + writemsg_level("".join(prefix + "%s\n" % line for line in msg), + level=3Dlogging.WARNING, noiselevel=3D-1) + + # Add lib providers to the graph as children of lib consumers, + # and also add any dependencies pulled in by the provider. + writemsg_level(">>> Adding lib providers to graph...\n") + + for pkg, consumers in consumer_map.items(): + for consumer_dblink in set(chain(*consumers.values())): + consumer_pkg =3D resolver._pkg(consumer_dblink.mycpv, + "installed", root_config, installed=3DTrue) + if not resolver._add_pkg(pkg, + Dependency(parent=3Dconsumer_pkg, + priority=3DUnmergeDepPriority(runtime=3DTrue), + root=3Dpkg.root)): + resolver.display_problems() + return True, [], False, 0, [] + + writemsg_level("\nCalculating dependencies ") + success =3D resolver._complete_graph( + required_sets=3D{myroot:required_sets}) + writemsg_level("\b\b... done!\n") + resolver.display_problems() + if not success: + return True, [], False, 0, [] + unresolvable =3D unresolved_deps() + if not unresolvable is None: + return False, [], False, 0, unresolvable + + graph =3D resolver._dynamic_config.digraph.copy() + required_pkgs_total =3D 0 + for node in graph: + if isinstance(node, Package): + required_pkgs_total +=3D 1 + cleanlist =3D create_cleanlist() + if not cleanlist: + return 0, [], False, required_pkgs_total, unresolvable + clean_set =3D set(cleanlist) + + if clean_set: + writemsg_level(">>> Calculating removal order...\n") + # Use a topological sort to create an unmerge order such that + # each package is unmerged before it's dependencies. This is + # necessary to avoid breaking things that may need to run + # during pkg_prerm or pkg_postrm phases. + + # Create a new graph to account for dependencies between the + # packages being unmerged. + graph =3D digraph() + del cleanlist[:] + + dep_keys =3D ["DEPEND", "RDEPEND", "PDEPEND"] + runtime =3D UnmergeDepPriority(runtime=3DTrue) + runtime_post =3D UnmergeDepPriority(runtime_post=3DTrue) + buildtime =3D UnmergeDepPriority(buildtime=3DTrue) + priority_map =3D { + "RDEPEND": runtime, + "PDEPEND": runtime_post, + "DEPEND": buildtime, + } + + for node in clean_set: + graph.add(node, None) + mydeps =3D [] + for dep_type in dep_keys: + depstr =3D node.metadata[dep_type] + if not depstr: + continue + priority =3D priority_map[dep_type] + + try: + atoms =3D resolver._select_atoms(myroot, depstr, + myuse=3Dnode.use.enabled, parent=3Dnode, + priority=3Dpriority)[node] + except portage.exception.InvalidDependString: + # Ignore invalid deps of packages that will + # be uninstalled anyway. + continue + + for atom in atoms: + if not isinstance(atom, portage.dep.Atom): + # Ignore invalid atoms returned from dep_check(). + continue + if atom.blocker: + continue + matches =3D vardb.match_pkgs(atom) + if not matches: + continue + for child_node in matches: + if child_node in clean_set: + graph.add(child_node, node, priority=3Dpriority) + + ordered =3D True + if len(graph.order) =3D=3D len(graph.root_nodes()): + # If there are no dependencies between packages + # let unmerge() group them by cat/pn. + ordered =3D False + cleanlist =3D [pkg.cpv for pkg in graph.order] + else: + # Order nodes from lowest to highest overall reference count for + # optimal root node selection (this can help minimize issues + # with unaccounted implicit dependencies). + node_refcounts =3D {} + for node in graph.order: + node_refcounts[node] =3D len(graph.parent_nodes(node)) + def cmp_reference_count(node1, node2): + return node_refcounts[node1] - node_refcounts[node2] + graph.order.sort(key=3Dcmp_sort_key(cmp_reference_count)) + + ignore_priority_range =3D [None] + ignore_priority_range.extend( + range(UnmergeDepPriority.MIN, UnmergeDepPriority.MAX + 1)) + while graph: + for ignore_priority in ignore_priority_range: + nodes =3D graph.root_nodes(ignore_priority=3Dignore_priority) + if nodes: + break + if not nodes: + raise AssertionError("no root nodes") + if ignore_priority is not None: + # Some deps have been dropped due to circular dependencies, + # so only pop one node in order to minimize the number that + # are dropped. + del nodes[1:] + for node in nodes: + graph.remove(node) + cleanlist.append(node.cpv) + + return True, cleanlist, ordered, required_pkgs_total, [] + return True, [], False, required_pkgs_total, [] diff --git a/gobs/pym/flags.py b/gobs/pym/flags.py index ba9faf6..c2e3bcc 100644 --- a/gobs/pym/flags.py +++ b/gobs/pym/flags.py @@ -1,3 +1,4 @@ +from __future__ import print_function from _emerge.main import parse_opts from _emerge.depgraph import backtrack_depgraph, depgraph, resume_depgra= ph from _emerge.create_depgraph_params import create_depgraph_params @@ -154,20 +155,21 @@ class gobs_use_flags(object): return iuse_flags, final_flags =20 def get_needed_dep_useflags(self, build_use_flags_list): + cpv =3D self._cpv tmpcmdline =3D [] tmpcmdline.append("-p") tmpcmdline.append("--autounmask") tmpcmdline.append("=3D" + self._cpv) - print tmpcmdline + print(tmpcmdline) myaction, myopts, myfiles =3D parse_opts(tmpcmdline, silent=3DFalse) - print myaction, myopts, myfiles + print(myaction, myopts, myfiles) myparams =3D create_depgraph_params(myopts, myaction) - print myparams + print(myparams) settings, trees, mtimedb =3D load_emerge_config() try: success, mydepgraph, favorites =3D backtrack_depgraph( settings, trees, myopts, myparams, myaction, myfiles, spinner=3DNone= ) - print success, mydepgraph, favorites + print(success, mydepgraph, favorites) except portage.exception.PackageSetNotFound as e: root_config =3D trees[settings["ROOT"]]["root_config"] display_missing_pkg_set(root_config, e.value) @@ -179,23 +181,22 @@ class gobs_use_flags(object): use_changes =3D {} for pkg, needed_use_config_changes in mydepgraph._dynamic_config._nee= ded_use_config_changes.items(): new_use, changes =3D needed_use_config_changes - use_changes[pkg.self._cpv] =3D changes - print use_changes + use_changes[pkg.cpv] =3D changes if use_changes is None: return None iteritems_packages =3D {} for k, v in use_changes.iteritems(): k_package =3D portage.versions.cpv_getkey(k) iteritems_packages[ k_package ] =3D v - print iteritems_packages + print('iteritems_packages', iteritems_packages) return iteritems_packages =09 def comper_useflags(self, build_dict): iuse_flags, use_enable =3D self.get_flags() iuse =3D [] - print "use_enable", use_enable + print("use_enable", use_enable) build_use_flags_dict =3D build_dict['build_useflags'] - print "build_use_flags_dict", build_use_flags_dict + print("build_use_flags_dict", build_use_flags_dict) build_use_flags_list =3D [] if use_enable =3D=3D []: if build_use_flags_dict is None: @@ -209,10 +210,10 @@ class gobs_use_flags(object): use_flagsDict[x] =3D True for x in use_disable: use_flagsDict[x] =3D False - print "use_flagsDict", use_flagsDict + print("use_flagsDict", use_flagsDict) for k, v in use_flagsDict.iteritems(): - print "tree use flags", k, v - print "db use flags", k, build_use_flags_dict[k] + print("tree use flags", k, v) + print("db use flags", k, build_use_flags_dict[k]) if build_use_flags_dict[k] !=3D v: if build_use_flags_dict[k] is True: build_use_flags_list.append(k) @@ -220,5 +221,5 @@ class gobs_use_flags(object): build_use_flags_list.append("-" + k) if build_use_flags_list =3D=3D []: build_use_flags_list =3D None - print build_use_flags_list + print(build_use_flags_list) return build_use_flags_list diff --git a/gobs/pym/old_cpv.py b/gobs/pym/old_cpv.py index 9dacd82..8a1a9c5 100644 --- a/gobs/pym/old_cpv.py +++ b/gobs/pym/old_cpv.py @@ -1,3 +1,4 @@ +from __future__ import print_function class gobs_old_cpv(object): =09 def __init__(self, CM, myportdb, mysettings): @@ -25,14 +26,14 @@ class gobs_old_cpv(object): # Set no active on ebuilds in the db that no longer in tree if old_ebuild_list !=3D []: for old_ebuild in old_ebuild_list: - print "O", categories + "/" + package + "-" + old_ebuild[0] + print("O", categories + "/" + package + "-" + old_ebuild[0]) self.dbquerys.add_old_ebuild(conn,package_id, old_ebuild_list) # Check if we have older no activ ebuilds then 60 days ebuild_old_list_db =3D self.dbquerys.cp_list_old_db(conn,package_id) # Delete older ebuilds in the db if ebuild_old_list_db !=3D []: for del_ebuild_old in ebuild_old_list_db: - print "D", categories + "/" + package + "-" + del_ebuild_old[1] + print("D", categories + "/" + package + "-" + del_ebuild_old[1]) self.dbquerys.del_old_ebuild(conn,ebuild_old_list_db) self._CM.putConnection(conn) =20 @@ -52,14 +53,14 @@ class gobs_old_cpv(object): if mark_old_list !=3D []: for x in mark_old_list: element =3D self.dbquerys.get_cp_from_package_id(conn,x) - print "O", element[0] + print("O", element[0]) # Check if we have older no activ categories/package then 60 days del_package_id_old_list =3D self.dbquerys.cp_all_old_db(conn,old_pack= age_id_list) # Delete older categories/package and ebuilds in the db if del_package_id_old_list !=3D []: for i in del_package_id_old_list: element =3D self.dbquerys.get_cp_from_package_id(conn,i) - print "D", element + print("D", element) self.dbquerys.del_old_package(conn,del_package_id_old_list) self._CM.putConnection(conn) =09 @@ -80,5 +81,5 @@ class gobs_old_cpv(object): if categories_old_list !=3D []: for real_old_categories in categories_old_list: self.dbquerys.del_old_categories(conn,real_old_categoriess) - print "D", real_old_categories + print("D", real_old_categories) self._CM.putConnection(conn) \ No newline at end of file diff --git a/gobs/pym/package.py b/gobs/pym/package.py index 46e13cb..4f0864d 100644 --- a/gobs/pym/package.py +++ b/gobs/pym/package.py @@ -1,3 +1,4 @@ +from __future__ import print_function import portage from gobs.flags import gobs_use_flags from gobs.repoman_gobs import gobs_repoman @@ -157,37 +158,10 @@ class gobs_package(object): # Comper ebuild_version and add the ebuild_version to buildqueue if portage.vercmp(v['ebuild_version_tree'], latest_ebuild_version) = =3D=3D 0: self._dbquerys.add_new_package_buildqueue(conn,ebuild_id, config_i= d, use_flags_list, use_enable_list, message) - print "B", config_id, v['categories'] + "/" + v['package'] + "-" = + latest_ebuild_version, "USE:", use_enable # B =3D Build config cpv use-= flags + print("B", config_id, v['categories'] + "/" + v['package'] + "-" = + latest_ebuild_version, "USE:", use_enable) # B =3D Build config cpv use= -flags i =3D i +1 self._CM.putConnection(conn) =20 - def add_new_ebuild_buildquery_db_looked(self, build_dict, config_profil= e): - conn=3Dself._CM.getConnection() - myportdb =3D portage.portdbapi(mysettings=3Dself._mysettings) - cpv =3D build_dict['cpv'] - message =3D None - init_useflags =3D gobs_use_flags(self._mysettings, myportdb, cpv) - iuse_flags_list, final_use_list =3D init_useflags.get_flags_looked() - iuse =3D [] - use_flags_list =3D [] - use_enable_list =3D [] - for iuse_line in iuse_flags_list: - iuse.append(init_useflags.reduce_flag(iuse_line)) - iuse_flags_list2 =3D list(set(iuse)) - use_enable =3D final_use_list - use_disable =3D list(set(iuse_flags_list2).difference(set(use_enable))= ) - use_flagsDict =3D {} - for x in use_enable: - use_flagsDict[x] =3D True - for x in use_disable: - use_flagsDict[x] =3D False - for u, s in use_flagsDict.iteritems(): - use_flags_list.append(u) - use_enable_list.append(s) - ebuild_id =3D self._dbquerys.get_ebuild_id_db_checksum(conn, build_dic= t) - self._dbquerys.add_new_package_buildqueue(conn, ebuild_id, config_prof= ile, use_flags_list, use_enable_list, message) - self._CM.putConnection(conn) - def get_package_metadataDict(self, pkgdir, package): # Make package_metadataDict attDict =3D {} @@ -206,7 +180,7 @@ class gobs_package(object): def add_new_package_db(self, categories, package): conn=3Dself._CM.getConnection() # add new categories package ebuild to tables package and ebuilds - print "N", categories + "/" + package # N =3D New Package + print("N", categories + "/" + package) # N =3D New Package pkgdir =3D self._mysettings['PORTDIR'] + "/" + categories + "/" + pack= age # Get PORTDIR + cp categories_dir =3D self._mysettings['PORTDIR'] + "/" + categories + "/= " # Get the ebuild list for cp @@ -231,7 +205,7 @@ class gobs_package(object): manifest_error =3D init_manifest.digestcheck() if manifest_error is not None: qa_error.append(manifest_error) - print "QA:", categories + "/" + package, qa_error + print("QA:", categories + "/" + package, qa_error) self._dbquerys.add_qa_repoman(conn,ebuild_id_list, qa_error, packageD= ict, config_id) # Add the ebuild to the buildqueru table if needed self.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config= _cpv_listDict) @@ -256,7 +230,7 @@ class gobs_package(object): # if we have the same checksum return else update the package ebuild_list_tree =3D self._myportdb.cp_list((categories + "/" + packag= e), use_cache=3D1, mytree=3DNone) if manifest_checksum_tree !=3D manifest_checksum_db: - print "U", categories + "/" + package # U =3D Update + print("U", categories + "/" + package) # U =3D Update # Get package_metadataDict and update the db with it package_metadataDict =3D self.get_package_metadataDict(pkgdir, packag= e) self._dbquerys.update_new_package_metadata(conn,package_id, package_m= etadataDict) @@ -276,9 +250,9 @@ class gobs_package(object): # Get packageDict for ebuild packageDict[ebuild_line] =3D self.get_packageDict(pkgdir, ebuild_li= ne, categories, package, config_id) if ebuild_version_manifest_checksum_db is None: - print "N", categories + "/" + package + "-" + ebuild_version_tree = # N =3D New ebuild + print("N", categories + "/" + package + "-" + ebuild_version_tree)= # N =3D New ebuild else: - print "U", categories + "/" + package + "-" + ebuild_version_tree = # U =3D Updated ebuild + print("U", categories + "/" + package + "-" + ebuild_version_tree)= # U =3D Updated ebuild # Fix so we can use add_new_package_sql(packageDict) to update the= ebuilds old_ebuild_list.append(ebuild_version_tree) self._dbquerys.add_old_ebuild(conn,package_id, old_ebuild_list) @@ -297,7 +271,7 @@ class gobs_package(object): manifest_error =3D init_manifest.digestcheck() if manifest_error is not None: qa_error.append(manifest_error) - print "QA:", categories + "/" + package, qa_error + print("QA:", categories + "/" + package, qa_error) self._dbquerys.add_qa_repoman(conn,ebuild_id_list, qa_error, packageD= ict, config_id) # Add the ebuild to the buildqueru table if needed self.add_new_ebuild_buildquery_db(ebuild_id_list, packageDict, config= _cpv_listDict) @@ -324,4 +298,4 @@ class gobs_package(object): self._dbquerys.add_old_ebuild(conn,package_id, old_ebuild_list) self._dbquerys.update_active_ebuild(conn,package_id, ebuild_version_t= ree) return_id =3D self._dbquerys.add_new_package_sql(conn,packageDict) - print 'return_id', return_id \ No newline at end of file + print('return_id', return_id) \ No newline at end of file diff --git a/gobs/pym/text.py b/gobs/pym/text.py index 9f5bb4e..2f1f689 100644 --- a/gobs/pym/text.py +++ b/gobs/pym/text.py @@ -1,3 +1,4 @@ +from __future__ import print_function import sys import re import os @@ -7,10 +8,8 @@ def get_file_text(filename): # Return the filename contents try: textfile =3D open(filename) - except IOError, oe: - if oe.errno not in (errno.ENOENT, ): - raise - return "No file", filename + except: + return "No file", filename text =3D "" for line in textfile: text +=3D unicode(line, 'utf-8') @@ -21,10 +20,8 @@ def get_ebuild_text(filename): """Return the ebuild contents""" try: ebuildfile =3D open(filename) - except IOError, oe: - if oe.errno not in (errno.ENOENT, ): - raise - return "No Ebuild file there" + except: + return "No Ebuild file there" text =3D "" dataLines =3D ebuildfile.readlines() for i in dataLines: @@ -40,12 +37,10 @@ def get_ebuild_text(filename): =20 def get_log_text_list(filename): """Return the log contents as a list""" - print "filename", filename + print("filename", filename) try: logfile =3D open(filename) - except IOError, oe: - if oe.errno not in (errno.ENOENT, ): - raise + except: return None text =3D [] dataLines =3D logfile.readlines()