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

[Magnus Granberg]

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

Updated the pgsql

---
 gobs/pym/querys/pgsql.py |  338 ++++++++++++++++++++++++----------------------
 1 files changed, 174 insertions(+), 164 deletions(-)

diff --git a/gobs/pym/querys/pgsql.py b/gobs/pym/querys/pgsql.py
index e1d2802..021c37f 100644
--- a/gobs/pym/querys/pgsql.py
+++ b/gobs/pym/querys/pgsql.py
@@ -1,4 +1,6 @@
 #every function takes a connection as a parameter that is provided by the CM
+from __future__ import print_function
+
 def get_default_config(connection):
 	cursor = connection.cursor()
 	sqlQ = 'SELECT id FROM configs WHERE default_config = True'
@@ -10,88 +12,76 @@ def get_profile_checksum(connection, config_profile):
     sqlQ = "SELECT make_conf_checksum FROM configs WHERE active = 'True' AND id = %s AND updateing = 'False'"
     cursor.execute(sqlQ, (config_profile,))
     return cursor.fetchone()
-  
-def get_package_to_build(connection, config_profile, queue_id, new):
+
+def get_packages_to_build(connection, config_profile):
   cursor =connection.cursor()
-  print "queue_id config_profile", queue_id, config_profile
-  # get what to build
-  if new is True:
-    sqlQ1 = "SELECT ebuild_id, post_message FROM buildqueue WHERE config = %s AND queue_id = %s"
-  else:
-    sqlQ1 = "SELECT ebuild_id, post_message FROM buildqueue WHERE config = %s AND extract(epoch from (NOW()) - timestamp) > 7200 AND queue_id = %s"
+  # no point in returning dead ebuilds, to just chuck em out later
+  sqlQ1 = '''SELECT post_message, queue_id, ebuild_id FROM buildqueue WHERE config = %s AND extract(epoch from (NOW()) - timestamp) > 7200 ORDER BY queue_id LIMIT 1'''
+
+  sqlQ2 ='''SELECT ebuild_id,category,package_name,ebuild_version,ebuild_checksum FROM ebuilds,buildqueue,packages
+    WHERE buildqueue.ebuild_id=ebuilds.id AND ebuilds.package_id=packages.package_id AND queue_id = %s AND ebuilds.active = TRUE'''
+  
   # get use flags to use
-  sqlQ2 = "SELECT useflag, enabled FROM ebuildqueuedwithuses WHERE queue_id = %s"
-  # get ebuild version (v) and package id
-  sqlQ3 = 'SELECT ebuild_version, package_id, ebuild_checksum FROM ebuilds WHERE id = %s'
-  # get categoriy and package (c, p)
-  sqlQ4 ='SELECT category, package_name FROM packages WHERE package_id = %s'
-  build_dict = {}
-  build_useflags_dict = {}
-  cursor.execute(sqlQ1, (config_profile, queue_id))
+  sqlQ3 = "SELECT useflag, enabled FROM ebuildqueuedwithuses WHERE queue_id = %s"
+  cursor.execute(sqlQ1, (config_profile,))
+  build_dict={}
   entries = cursor.fetchone()
-  print "sqlQ1", entries
   if entries is None:
+    return None
+  if entries[2] is None:
     build_dict['ebuild_id'] = None
-    build_dict['post_message'] = None
+    build_dict['queue_id'] = entries[1]
     return build_dict
-  build_dict['queue_id'] = queue_id
-  ebuild_id = entries[0]
-  build_dict['ebuild_id'] = ebuild_id
-  build_dict['post_message'] = entries[1]
-  cursor.execute(sqlQ2, (queue_id,))
-  entries = cursor.fetchall()
-  print 'build_useflags', entries
-  if entries == []:
-    build_useflags = None
-  else:
-    build_useflags = entries
-  cursor.execute(sqlQ3, (ebuild_id,))
-  entries = cursor.fetchall()[0]
-  build_dict['ebuild_version'] = entries[0]
-  build_dict['package_id'] = entries[1]
-  build_dict['ebuild_checksum'] = entries[2]
-  cursor.execute(sqlQ4, (entries[1],))
-  entries = cursor.fetchall()[0]
-  build_dict['categories'] = entries[0]
-  build_dict['package'] = entries[1]
-  if build_useflags is None:
-    build_dict['build_useflags'] = None
-  else:
-    for x in build_useflags:
-      build_useflags_dict[x[0]] = x[1]
-      build_dict['build_useflags'] = build_useflags_dict
-  print "build_dict", build_dict
+  msg_list = []
+  if not entries[0] is None:
+    for msg in entries[0].split(" "):
+      msg_list.append(msg)
+  build_dict['post_message'] = msg_list
+  build_dict['queue_id'] = entries[1]
+  build_dict['ebuild_id']=entries[2]
+  cursor.execute(sqlQ2, (build_dict['queue_id'],))
+  #make a list that contains objects that haves ebuild_id and post_message +the lot as attributes
+  entries = cursor.fetchone()
+  if entries is None:
+    build_dict['checksum']= None
+    return build_dict
+  build_dict['ebuild_id']=entries[0]
+  build_dict['category']=entries[1]
+  build_dict['package']=entries[2]
+  build_dict['ebuild_version']=entries[3]
+  build_dict['checksum']=entries[4]
+
+  #add a enabled and disabled list to the objects in the item list
+  cursor.execute(sqlQ3, (build_dict['queue_id'],))
+  uses={}
+  for row in cursor.fetchall():
+    uses[ row[0] ] = row[1]
+  build_dict['build_useflags']=uses
   return build_dict
 
-def check_revision(connection, build_dict, config_profile, ebuild_version_checksum_tree):
+def check_revision(connection, build_dict):
   cursor = connection.cursor()
-  build_useflags = []
-  sqlQ1 = 'SELECT id FROM ebuilds WHERE ebuild_version = %s AND ebuild_checksum = %s AND package_id = %s'
-  sqlQ2 = 'SELECT queue_id FROM buildqueue WHERE ebuild_id = %s AND config = %s'
-  sqlQ3 = "SELECT useflag FROM ebuildqueuedwithuses WHERE queue_id = %s AND enabled = 'True'"
-  cursor.execute(sqlQ1, (build_dict['ebuild_version'], ebuild_version_checksum_tree, build_dict['package_id']))
-  ebuild_id = cursor.fetchone()
-  print "ebuild_id", ebuild_id
-  if ebuild_id is None:
-    return None
-  cursor.execute(sqlQ2, (ebuild_id[0], config_profile))
+  sqlQ1 = 'SELECT queue_id FROM buildqueue WHERE ebuild_id = %s AND config = %s'
+  sqlQ2 = "SELECT useflag FROM ebuildqueuedwithuses WHERE queue_id = %s AND enabled = 'True'"
+  cursor.execute(sqlQ1, (build_dict['ebuild_id'], build_dict['config_profile']))
   queue_id_list = cursor.fetchall()
-  print 'queue_id_list',  queue_id_list 
+  print('queue_id_list',  queue_id_list)
   if queue_id_list == []:
     return None
-  for queue_id in queue_id_list[0]:
-    print 'queue_id', queue_id
-    cursor.execute(sqlQ3, (queue_id,))
+  for queue_id in queue_id_list:
+    print('queue_id after list', queue_id[0])
+    cursor.execute(sqlQ2, (queue_id[0],))
     entries = cursor.fetchall()
+    build_useflags = []
     if entries == []:
       build_useflags = None
     else:
       for use_line in sorted(entries):
-	      build_useflags.append(unicode(use_line[0]))
-    print "build_useflags build_dict['build_useflags']", build_useflags, build_dict['build_useflags']
+	      build_useflags.append(use_line[0])
+    print("build_useflags build_dict['build_useflags']", build_useflags, build_dict['build_useflags'])
     if build_useflags == build_dict['build_useflags']:
-      print 'queue_id', queue_id
-      return queue_id
+      print('queue_id', queue_id[0])
+      return queue_id[0]
   return None
 
 def get_config_list(connection):
@@ -261,18 +251,18 @@ def add_new_ebuild_sql(connection, packageDict, new_ebuild_list):
   for k, v in packageDict.iteritems():
     for x in new_ebuild_list:
       if x == v['ebuild_version_tree']:
-	params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
-	v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
-	v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
-	v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
-	v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
-	v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
-	v['ebuild_version_metadata_tree'][16]]
-	cursor.execute(sqlQ, params)
-	mid = cursor.fetchone()
-	mid=mid[0]
-	ebuild_id_list.append(mid[1])
-	package_id_list.append(mid[0])
+        params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
+        v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
+        v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
+        v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
+        v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
+        v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
+        v['ebuild_version_metadata_tree'][16]]
+        cursor.execute(sqlQ, params)
+        mid = cursor.fetchone()
+        mid=mid[0]
+        ebuild_id_list.append(mid[1])
+        package_id_list.append(mid[0])
   connection.commit()
   # add_new_metadata(metadataDict)
   return ebuild_id_list, package_id_list
@@ -295,10 +285,10 @@ def get_ebuild_id_db_checksum(connection, build_dict):
 	sqlQ = 'SELECT id FROM ebuilds WHERE ebuild_version = %s AND ebuild_checksum = %s AND package_id = %s'
 	cursor.execute(sqlQ, (build_dict['ebuild_version'], build_dict['checksum'], build_dict['package_id']))
 	ebuild_id = cursor.fetchone()
-	print 'ebuild_id', ebuild_id
+	print('ebuild_id', ebuild_id)
 	if ebuild_id is None:
 		return None
-	return ebuild_id
+	return ebuild_id[0]
 
 def get_cpv_from_ebuild_id(connection, ebuild_id):
 	cursor = connection.cursor()
@@ -343,7 +333,7 @@ def add_new_package_buildqueue(connection, ebuild_id, config_id, iuse_flags_list
   if not iuse_flags_list:
     iuse_flags_list=None
     use_enable=None
-  params = ebuild_id, unicode(config_id), iuse_flags_list, use_enable, message
+  params = ebuild_id, config_id, iuse_flags_list, use_enable, message
   cursor.execute(sqlQ, params)
   connection.commit()
   
@@ -397,17 +387,17 @@ def add_old_ebuild(connection, package_id, old_ebuild_list):
   sqlQ4 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
   sqlQ5 = 'DELETE FROM buildqueue WHERE queue_id = %s'
   for old_ebuild in  old_ebuild_list:
-	  cursor.execute(sqlQ2, (package_id, old_ebuild[0]))
-	  ebuild_id_list = cursor.fetchall()
-	  if ebuild_id_list is not None:
-		for ebuild_id in ebuild_id_list:
-			cursor.execute(sqlQ3, (ebuild_id))
-			queue_id_list = cursor.fetchall()
-			if queue_id_list is not None:
-				for queue_id in queue_id_list:
-					cursor.execute(sqlQ4, (queue_id))
-					cursor.execute(sqlQ5, (queue_id))
-		cursor.execute(sqlQ1, (package_id, old_ebuild[0]))
+    cursor.execute(sqlQ2, (package_id, old_ebuild[0]))
+    ebuild_id_list = cursor.fetchall()
+    if ebuild_id_list is not None:
+      for ebuild_id in ebuild_id_list:
+        cursor.execute(sqlQ3, (ebuild_id))
+        queue_id_list = cursor.fetchall()
+        if queue_id_list is not None:
+          for queue_id in queue_id_list:
+            cursor.execute(sqlQ4, (queue_id))
+            cursor.execute(sqlQ5, (queue_id))
+        cursor.execute(sqlQ1, (package_id, old_ebuild[0]))
   connection.commit()
   
 def cp_all_old_db(connection, old_package_id_list):
@@ -420,41 +410,51 @@ def cp_all_old_db(connection, old_package_id_list):
     if entries is None:
       old_package_list.append(old_package)
   return old_package_list
-  
+
+def del_old_queue(connection, queue_id):
+	cursor = connection.cursor()
+	sqlQ1 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
+	sqlQ2 = 'DELETE FROM temp_errors_queue_qa WHERE queue_id  = %s'
+	sqlQ3 = 'DELETE FROM buildqueue WHERE queue_id  = %s'
+	cursor.execute(sqlQ1, (queue_id,))
+	cursor.execute(sqlQ2, (queue_id,))
+	cursor.execute(sqlQ3, (queue_id,))
+	connection.commit()
+
 def del_old_ebuild(connection, ebuild_old_list_db):
-  cursor = connection.cursor()
-  sqlQ1 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s'
-  sqlQ2 = 'DELETE FROM qa_problems WHERE build_id = %s'
-  sqlQ3 = 'DELETE FROM repoman_problems WHERE build_id = %s'
-  sqlQ4 = 'DELETE FROM ebuildbuildwithuses WHERE build_id = %s'
-  sqlQ5 = 'DELETE FROM ebuildhaveskeywords WHERE ebuild_id = %s'
-  sqlQ6 = 'DELETE FROM ebuildhavesiuses WHERE ebuild_id = %s'
-  sqlQ7 = 'DELETE FROM ebuildhavesrestrictions WHERE ebuild_id = %s'
-  sqlQ8 = 'DELETE FROM buildlog WHERE ebuild_id = %s'
-  sqlQ9 = 'SELECT queue_id FROM buildqueue WHERE ebuild_id = %s'
-  sqlQ10 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
-  sqlQ11 = 'DELETE FROM buildqueue WHERE ebuild_id  = %s'
-  sqlQ12 = 'DELETE FROM ebuilds WHERE id  = %s'
-  for ebuild_id in ebuild_old_list_db:
-	cursor.execute(sqlQ1, (ebuild_id[0],))
-	build_id_list = cursor.fetchall()
-	if  build_id_list != []:
-		for build_id in build_id_list:
-			cursor.execute(sqlQ2, (build_id[0],))
-			cursor.execute(sqlQ3, (build_id[0],))
-			cursor.execute(sqlQ4, (build_id[0],))
-	cursor.execute(sqlQ9, (ebuild_id[0],))
-	queue_id_list = cursor.fetchall()
-	if queue_id_list != []:
-		for queue_id in queue_id_list:
-			cursor.execute(sqlQ10, (queue_id[0],))
-	cursor.execute(sqlQ5, (ebuild_id[0],))
-	cursor.execute(sqlQ6, (ebuild_id[0],))
-	cursor.execute(sqlQ7, (ebuild_id[0],))
-	cursor.execute(sqlQ8, (ebuild_id[0],))
-	cursor.execute(sqlQ11, (ebuild_id[0],))
-	cursor.execute(sqlQ12, (ebuild_id[0],))
-  connection.commit()
+	cursor = connection.cursor()
+	sqlQ1 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s'
+	sqlQ2 = 'DELETE FROM qa_problems WHERE build_id = %s'
+	sqlQ3 = 'DELETE FROM repoman_problems WHERE build_id = %s'
+	sqlQ4 = 'DELETE FROM ebuildbuildwithuses WHERE build_id = %s'
+	sqlQ5 = 'DELETE FROM ebuildhaveskeywords WHERE ebuild_id = %s'
+	sqlQ6 = 'DELETE FROM ebuildhavesiuses WHERE ebuild_id = %s'
+	sqlQ7 = 'DELETE FROM ebuildhavesrestrictions WHERE ebuild_id = %s'
+	sqlQ8 = 'DELETE FROM buildlog WHERE ebuild_id = %s'
+	sqlQ9 = 'SELECT queue_id FROM buildqueue WHERE ebuild_id = %s'
+	sqlQ10 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
+	sqlQ11 = 'DELETE FROM buildqueue WHERE ebuild_id  = %s'
+	sqlQ12 = 'DELETE FROM ebuilds WHERE id  = %s'
+	for ebuild_id in ebuild_old_list_db:
+		cursor.execute(sqlQ1, (ebuild_id[0],))
+		build_id_list = cursor.fetchall()
+		if  build_id_list != []:
+			for build_id in build_id_list:
+				cursor.execute(sqlQ2, (build_id[0],))
+				cursor.execute(sqlQ3, (build_id[0],))
+				cursor.execute(sqlQ4, (build_id[0],))
+		cursor.execute(sqlQ9, (ebuild_id[0],))
+		queue_id_list = cursor.fetchall()
+		if queue_id_list != []:
+			for queue_id in queue_id_list:
+				cursor.execute(sqlQ10, (queue_id[0],))
+		cursor.execute(sqlQ5, (ebuild_id[0],))
+		cursor.execute(sqlQ6, (ebuild_id[0],))
+		cursor.execute(sqlQ7, (ebuild_id[0],))
+		cursor.execute(sqlQ8, (ebuild_id[0],))
+		cursor.execute(sqlQ11, (ebuild_id[0],))
+		cursor.execute(sqlQ12, (ebuild_id[0],))
+	connection.commit()
   
 def del_old_package(connection, package_id_list):
   cursor = connection.cursor()
@@ -464,13 +464,13 @@ def del_old_package(connection, package_id_list):
   sqlQ4 = 'DELETE FROM packages_meta WHERE package_id = %s'
   sqlQ5 = 'DELETE FROM packages WHERE package_id = %s'
   for package_id in package_id_list:
-	  cursor.execute(sqlQ1, package_id)
-	  ebuild_id_list = cursor.fetchall()
-	  del_old_ebuild(connection, ebuild_id_list)
-	  cursor.execute(sqlQ2, (package_id,))
-	  cursor.execute(sqlQ3, (package_id,))
-	  cursor.execute(sqlQ4, (package_id,))
-	  cursor.execute(sqlQ5, (package_id,))
+    cursor.execute(sqlQ1, package_id)
+    ebuild_id_list = cursor.fetchall()
+    del_old_ebuild(connection, ebuild_id_list)
+    cursor.execute(sqlQ2, (package_id,))
+    cursor.execute(sqlQ3, (package_id,))
+    cursor.execute(sqlQ4, (package_id,))
+    cursor.execute(sqlQ5, (package_id,))
   connection.commit()
 
 def cp_list_db(connection, package_id):
@@ -485,14 +485,29 @@ def cp_list_old_db(connection, package_id):
   cursor.execute(sqlQ, package_id)
   return cursor.fetchall()
 
-def move_queru_buildlog(connection, queue_id, build_error, summary_error, logfilename, build_log_dict):
+def move_queru_buildlog(connection, queue_id, build_error, summary_error, build_log_dict):
 	cursor = connection.cursor()
-	print 'queue_id', queue_id
-	print 'build_log_dict', build_log_dict
+	print('queue_id', queue_id)
+	print('build_log_dict', build_log_dict)
 	repoman_error_list = build_log_dict['repoman_error_list']
 	qa_error_list = build_log_dict['qa_error_list']
 	sqlQ = 'SELECT make_buildlog( %s, %s, %s, %s, %s, %s)'
-	cursor.execute(sqlQ, (queue_id, summary_error, build_error, logfilename, qa_error_list, repoman_error_list))
+	cursor.execute(sqlQ, (queue_id, summary_error, build_error, build_log_dict['logfilename'], qa_error_list, repoman_error_list))
+	entries = cursor.fetchone()
+	connection.commit()
+	return entries
+
+def add_new_buildlog(connection, build_dict, use_flags_list, use_enable_list, build_error, summary_error, build_log_dict):
+	cursor = connection.cursor()
+	repoman_error_list = build_log_dict['repoman_error_list']
+	qa_error_list = build_log_dict['qa_error_list']
+	if not use_flags_list:
+    		use_flags_list=None
+    		use_enable=None
+    	print('make_deplog', build_dict['ebuild_id'], build_dict['config_profile'], use_flags_list, use_enable_list, summary_error, build_error, build_log_dict['logfilename'], qa_error_list, repoman_error_list)
+	sqlQ = 'SELECT make_deplog( %s, %s, %s, %s, %s, %s, %s, %s, %s)'
+	params = (build_dict['ebuild_id'], build_dict['config_profile'], use_flags_list, use_enable_list, summary_error, build_error, build_log_dict['logfilename'], qa_error_list, repoman_error_list)
+	cursor.execute(sqlQ, params)
 	entries = cursor.fetchone()
 	connection.commit()
 	return entries
@@ -505,24 +520,24 @@ def add_qa_repoman(connection, ebuild_id_list, qa_error, packageDict, config_id)
     sqlQ = "INSERT INTO buildlog (ebuild_id, config, error_summary, timestamp, hash ) VALUES  ( %s, %s, %s, now(), '1' ) RETURNING build_id"
     if v['ebuild_error'] != [] or qa_error != []:
       if v['ebuild_error'] != [] or qa_error == []:
-	summary = "Repoman"
+        summary = "Repoman"
       elif v['ebuild_error'] == [] or qa_error != []:
-	summary = "QA"
+        summary = "QA"
       else:
-	summary = "QA:Repoman"
+        summary = "QA:Repoman"
       params = (ebuild_id, config_id, summary)
       cursor.execute(sqlQ, params)
       build_id = cursor.fetchone()
       if v['ebuild_error'] != []:
-	sqlQ = 'INSERT INTO repoman_problems (problem, build_id ) VALUES ( %s, %s )'
-	for x in v['ebuild_error']:
-	  params = (x, build_id)
-	  cursor.execute(sqlQ, params)
+        sqlQ = 'INSERT INTO repoman_problems (problem, build_id ) VALUES ( %s, %s )'
+        for x in v['ebuild_error']:
+          params = (x, build_id)
+          cursor.execute(sqlQ, params)
       if qa_error != []:
-	sqlQ = 'INSERT INTO qa_problems (problem, build_id ) VALUES ( %s, %s )'
-	for x in qa_error:
-	  params = (x, build_id)
-	  cursor.execute(sqlQ, params)
+        sqlQ = 'INSERT INTO qa_problems (problem, build_id ) VALUES ( %s, %s )'
+        for x in qa_error:
+          params = (x, build_id)
+          cursor.execute(sqlQ, params)
     ebuild_i = ebuild_i +1
   connection.commit()
 
@@ -553,33 +568,28 @@ def add_new_arch_db(connection, arch_list):
     cursor.execute(sqlQ, (arch,))
   connection.commit()
 
-def check_fail_times(connection, queue_id, what_error):
+def check_fail_times(connection, logDict):
+	queue_id = logDict['queue_id']
+	qa_error = logDict['qa_error_list'][0]
 	cursor = connection.cursor()
 	sqlQ = 'SELECT errors FROM temp_errors_queue_qa WHERE queue_id = %s AND what_error = %s'
-	cursor.execute(sqlQ, (queue_id, what_error))
+	cursor.execute(sqlQ, (queue_id, qa_error,))
 	return cursor.fetchone()
 
-def add_fail_times(connection, queue_id, what_error):
+def add_fail_times(connection, logDict):
+	queue_id = logDict['queue_id']
+	qa_error = logDict['qa_error_list'][0]
 	cursor = connection.cursor()
-	x = 1
-	sqlQ = 'INSERT INTO temp_errors_queue_qa (queue_id, what_error, errors) VALUES ( %s, %s, %s)'
-	cursor.execute(sqlQ, (queue_id, what_error, x))
+	sqlQ = 'INSERT INTO temp_errors_queue_qa (queue_id, what_error) VALUES ( %s, %s)'
+	cursor.execute(sqlQ, (queue_id, qa_error,))
 	connection.commit()
 
-def update_fail_times(connection, queue_id, what_error, fail_times):
-	cursor = connection.cursor()
-	x = fail_times + 1
-	sqlQ = 'UPDATE temp_errors_queue_qa SET errors = %s WHERE queue_id = %s AND what_error = %s'
-	cursor.execute(sqlQ, (x, queue_id, what_error))
-	connection.commit()
-def del_old_queue(connection, queue_id):
+def update_fail_times(connection, logDict):
+	queue_id = logDict['queue_id']
+	qa_error = logDict['qa_error_list'][0]
 	cursor = connection.cursor()
-	sqlQ1 = 'DELETE FROM ebuildqueuedwithuses WHERE queue_id = %s'
-	sqlQ2 = 'DELETE FROM temp_errors_queue_qa WHERE queue_id  = %s'
-	sqlQ3 = 'DELETE FROM buildqueue WHERE queue_id  = %s'
+	sqlQ1 = 'UPDATE buildqueue SET timestamp = NOW() WHERE queue_id = %s'
 	cursor.execute(sqlQ1, (queue_id,))
-	cursor.execute(sqlQ2, (queue_id,))
-	cursor.execute(sqlQ3, (queue_id,))
 	connection.commit()
 
 def make_conf_error(connection,config_profile):