[gentoo-commits] dev/zorry:master commit in: gobs/bin/

[Magnus Granberg]

commit:     467f8f50912235c3ea0be555f98abd394e3ece93
Author:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
AuthorDate: Fri Jul 29 15:16:53 2011 +0000
Commit:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
CommitDate: Fri Jul 29 15:16:53 2011 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=dev/zorry.git;a=commit;h=467f8f50

Updated the bins

---
 gobs/bin/gobs_buildquerys |  144 +-------------------------------------------
 gobs/bin/portage_hooks    |   41 +++++++------
 2 files changed, 26 insertions(+), 159 deletions(-)

diff --git a/gobs/bin/gobs_buildquerys b/gobs/bin/gobs_buildquerys
index bc7e320..87f1218 100755
--- a/gobs/bin/gobs_buildquerys
+++ b/gobs/bin/gobs_buildquerys
@@ -14,160 +14,24 @@ elif CM.getName()=='mysql':
   from gobs.querys.mysql import *
 
 from gobs.check_setup import check_configure_guest
-from gobs.flags import gobs_use_flags
-from gobs.manifest import gobs_manifest
-from _emerge.main import emerge_main
+from gobs.build_queru import queruaction
 import portage
 import sys
 import os
 
-def log_qa_error(connection, build_dict, what_error, fail_error, config_id):
-	ebuild_id_list = []
-	qa_error_list = []
-	repoman_error = []
-	ebuild_version = build_dict['ebuild_version']
-	attDict = {}
-	packageDict = {}
-	attDict['ebuild_error'] = repoman_error
-	packageDict[ebuild_version] = attDict
-	qa_error_list.append(fail_error)
-	fail_times = check_fail_times(connection, build_dict['queue_id'], what_error)
-	if fail_times is None:
-		add_fail_times(connection, build_dict['queue_id'], what_error)
-	else:
-		if fail_times[0] > 5:
-			return
-		elif fail_times[0] == 5:
-			ebuild_id_list.append(build_dict['ebuild_id'])
-			add_qa_repoman(connection, ebuild_id_list, qa_error_list, packageDict, config_id)
-			del_old_queue(connection, build_dict['queue_id'])
-			return
-		update_fail_times(connection, build_dict['queue_id'], what_error, fail_times[0])
-
-def get_cpv_build_list(connection, build_dict, config_profile):
-	build_cpv_dict = {}
-	cpv_dict = {}
-	cpv_list = "1"
-	mysettings = portage.settings
-	#myportdb = portage.portdbapi(mysettings=mysettings)
-	myportdb = portage.portdb
-	#porttree = portage.portagetree(settings=mysettings)
-	#trees = {"/" : {"porttree":porttree}}
-	#dep_keys = ("DEPEND", "RDEPEND", "PDEPEND")
-	pkgdir = os.path.join(mysettings['PORTDIR'], build_dict['categories'] + "/" + build_dict['package'])
-	init_manifest =  gobs_manifest(mysettings, pkgdir)
-	try:
-		ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir+ "/" + build_dict['package'] + "-" + build_dict['ebuild_version'] + ".ebuild")[0]
-	except:
-		ebuild_version_checksum_tree = None
-	print ebuild_version_checksum_tree, build_dict['ebuild_checksum']
-	ebuild_version_checksum_db = have_activ_ebuild_id(connection, build_dict['ebuild_id'])
-	print 'ebuild_version_checksum_db', ebuild_version_checksum_db
-	if ebuild_version_checksum_db is None:
-		print "queue_id don't have active ebuild_id"
-		del_old_queue(connection, build_dict['queue_id'])
-		return None
-	if ebuild_version_checksum_tree != build_dict['ebuild_checksum']:
-		new_queue_id = check_revision(connection, build_dict, config_profile, ebuild_version_checksum_tree)
-		if new_queue_id is None:
-			return None
-			# FIXME use  log_qa_error()
-			if check_fail_times(build_dict['queue_id'], "cpv_checksum") is False:
-				update_fail_times(build_dict['queue_id'], "cpv_checksum")
-			else:
-				add_cpv_fail(build_dict['queue_id'], "cpv_checksum")
-				return None
-		build_dict = get_package_to_build(connection,config_profile, new_queue_id)
-	categories = build_dict['categories']
-	package = build_dict['package']
-	ebuild_version = build_dict['ebuild_version']
-	ebuild_version_useflags = build_dict['build_useflags']
-	build_massage = build_dict['post_message']
-	cpv = unicode(categories + "/" + package + "-" + ebuild_version)
-	cp =  unicode(categories + "/" + package)
-	init_flags = gobs_use_flags(mysettings, myportdb, cpv)
-	#mysettings['O'] = pkgdir
-	print portage.getmaskingstatus(cpv, settings=mysettings, portdb=myportdb)
-	if portage.getmaskingstatus(cpv, settings=mysettings, portdb=myportdb) != []:
-		# FIXME use  log_qa_error()
-		if check_fail_times(build_dict['queue_id'], "cpv_mask") is False:
-			update_fail_times(build_dict['queue_id'], "cpv_mask")
-		else:
-			add_cpv_fail(build_dict['queue_id'], "cpv_mask")
-		return None
-	build_use_flags_list = init_flags.comper_useflags(build_dict)
-	manifest_error = init_manifest.check_file_in_manifest(myportdb, cpv, build_dict, build_use_flags_list)
-	print 'manifest_error', manifest_error
-	if manifest_error is not None:
-		what_error = "cpv_manifest"
-		log_qa_error(connection, build_dict, what_error, manifest_error, config_profile)
-		return None
-	build_cpv_dict = init_flags.get_needed_dep_useflags(build_use_flags_list)
-	print build_cpv_dict, build_use_flags_list, cpv
-	build_use_flags_dict = {}
-	if build_use_flags_list is None:
-		build_use_flags_dict['None'] = None
-	if build_cpv_dict is None:
-		build_cpv_dict = {}
-		build_cpv_dict[cpv] = build_use_flags_dict
-	else:
-		build_cpv_dict[cpv] = build_use_flags_dict
-	print build_cpv_dict
-	return build_cpv_dict
-												
 def main_loop(CM, config_profile):
 	repeat = True
-	new = False
-	queue_id_list = 43280
 	#get a connection from the pool
 	conn=CM.getConnection()
+	init_queru = queruaction(config_profile)
+	fail_querue_dict = {}
 	while repeat:
-		build_cpv_dict = {}
-		build_dict = {}
 		if check_configure_guest(conn, config_profile) is not True:
 			# time.sleep(60)
 			continue		# retunr to the start of the function
 		else:
-			build_dict = get_package_to_build(conn,config_profile, queue_id_list, new)
-			print "build_dict['ebuild_id'] build_dict['post_message']", build_dict['ebuild_id'], build_dict['post_message']
-			if build_dict['ebuild_id'] is None:
-				if build_dict['post_message'] is None:
-					# time.sleep(60)
-					print "build_dict none"
-					queue_id_list = queue_id_list + 1
-					print queue_id_list
-					continue 		# return to the start of the function
-			build_cpv_dict = get_cpv_build_list(conn, build_dict, config_profile)
-			if build_cpv_dict is None:
-				queue_id_list = queue_id_list + 1
-				continue		# return to the start of the function
-			build_cpv_list = []
-			for k, v in build_cpv_dict.iteritems():
-				build_use_flags_list = []
-				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 == []:
-					build_cpv_list.append("=" + k)
-				else:
-					build_use_flags = ""
-					for flags in build_use_flags_list:
-						build_use_flags = build_use_flags + flags + ","
-					build_cpv_list.append("=" + k + "[" + build_use_flags + "]")
-				print build_cpv_list
-			argscmd = []
-			# argscmd.append("--buildpkg")
-			# argscmd.append("--usepkg")
-			argscmd.append("--oneshot")
-			for build_cpv in build_cpv_list:
-				argscmd.append(build_cpv)
-			print argscmd
-			emerge_main(args=argscmd)
+			fail_querue_list = init_queru.procces_qureru(fail_querue_dict)
 			sys.exit()
-			queue_id_list = queue_id_list + 1
 		CM.putConnection(conn)
 
 def main():

diff --git a/gobs/bin/portage_hooks b/gobs/bin/portage_hooks
index 97c2576..bdb1699 100755
--- a/gobs/bin/portage_hooks
+++ b/gobs/bin/portage_hooks
@@ -1,5 +1,7 @@
 #!/usr/bin/python
-
+from __future__ import print_function
+import os
+import sys
 # Get the options from the config file set in gobs.readconf
 from gobs.readconf import get_conf_settings
 reader=get_conf_settings()
@@ -16,10 +18,10 @@ elif CM.getName()=='mysql':
 from gobs.package import gobs_package
 from gobs.build_log import gobs_buildlog
 from gobs.flags import gobs_use_flags
+from portage.util import writemsg, writemsg_level, writemsg_stdout
 import portage
-import os
 
-def get_build_dict_db(CM, mysettings, config_profile, gobs_settings_dict):
+def get_build_dict_db(mysettings, config_profile, gobs_settings_dict):
 	conn=CM.getConnection()
 	myportdb = portage.portdbapi(mysettings=mysettings)
 	categories = os.environ['CATEGORY']
@@ -27,9 +29,9 @@ def get_build_dict_db(CM, mysettings, config_profile, gobs_settings_dict):
 	ebuild_version = os.environ['PVR']
 	cpv = categories + "/" + package + "-" + ebuild_version
 	init_package = gobs_package(mysettings, CM, myportdb, gobs_settings_dict)
-	print "cpv", cpv
+	print("cpv", cpv)
 	package_id = have_package_db(conn, categories, package)
-	print "package_id", package_id
+	# print("package_id %s" % package_id, file=sys.stdout)
 	build_dict = {}
 	mybuild_dict = {}
 	build_dict['ebuild_version'] = ebuild_version
@@ -40,37 +42,38 @@ def get_build_dict_db(CM, mysettings, config_profile, gobs_settings_dict):
 	build_dict['config_profile'] = config_profile
 	init_useflags = gobs_use_flags(mysettings, myportdb, cpv)
 	iuse_flags_list, final_use_list = init_useflags.get_flags_looked()
-	print 'final_use_list', final_use_list
+	#print 'final_use_list', final_use_list
 	if  final_use_list != []:
 		build_dict['build_useflags'] = final_use_list
 	else:
 		build_dict['build_useflags'] = None
-	print "build_dict['build_useflags']", build_dict['build_useflags']
+	#print "build_dict['build_useflags']", build_dict['build_useflags']
 	pkgdir = os.path.join(mysettings['PORTDIR'], categories + "/" + package)
 	ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir+ "/" + package + "-" + ebuild_version + ".ebuild")[0]
 	build_dict['checksum'] = ebuild_version_checksum_tree
-	print 'checksum' ,ebuild_version_checksum_tree
+	print('checksum' ,ebuild_version_checksum_tree)
 	ebuild_id = get_ebuild_id_db_checksum(conn, build_dict)
-	print 'ebuild_id in db', ebuild_id
+	print('ebuild_id in db', ebuild_id)
 	if ebuild_id is None:
-		print 'have any ebuild',  get_ebuild_checksum(conn, package_id, ebuild_version)
+		#print 'have any ebuild',  get_ebuild_checksum(conn, package_id, ebuild_version)
 		init_package.update_ebuild_db(build_dict)
-	queue_id = check_revision(conn, build_dict, config_profile, ebuild_version_checksum_tree)
-	print "queue_id", queue_id
+		ebuild_id = get_ebuild_id_db_checksum(conn, build_dict)
+	build_dict['ebuild_id'] = ebuild_id
+	queue_id = check_revision(conn, build_dict)
+	print("queue_id in db", queue_id)
 	if queue_id is None:
-		init_package.add_new_ebuild_buildquery_db_looked(build_dict, config_profile)
-		queue_id = check_revision(conn, build_dict, config_profile, ebuild_version_checksum_tree)
-	mybuild_dict = get_package_to_build(conn, config_profile, queue_id, new = True)
-	print 'mybuild_dict', mybuild_dict
-	return mybuild_dict
+		build_dict['queue_id'] = None
+	else:
+		build_dict['queue_id'] = queue_id
+	return build_dict
 
 def main():
   # Main
   config_profile = gobs_settings_dict['gobs_config']
   #we provide the main_loop with the ConnectionManager so we can hand out connections from within the loop
   mysettings = portage.settings
-  build_dict = get_build_dict_db(CM, mysettings, config_profile, gobs_settings_dict)
-  init_buildlog = gobs_buildlog(CM ,mysettings, build_dict, config_profile)
+  build_dict = get_build_dict_db( mysettings, config_profile, gobs_settings_dict)
+  init_buildlog = gobs_buildlog(mysettings, build_dict)
   init_buildlog.add_buildlog_main()
   #connectionManager.closeAllConnections()