Subversion Repositories SE.SVN

import threading
import dbcontrol
import time


class Jobber(threading.Thread):

        
#       sql_nextjob = """SELECT * FROM %s 
#                                               WHERE sched<NOW() AND (NOT (sched IS NULL)) ORDER BY 
#                                               sched ASC LIMIT 1 FOR UPDATE """ % (self.db_table,)


        def get_selectjob_sql(self):
                return ""

        def get_markjob_sql(self,row):
                return ""




        def get_nextjob(self):

                db = self.db_pool.get_conn()

                try:
                        cursor=db.cursor()
                        while True:
                                try:
                                        (sql,p) = self.get_selectjob_sql()
                                        cursor.execute(sql,p)
                                        break
                                except Exception, e:
                                        if type(e) != dbcontrol.pgdb.OperationalError:
                                                raise e
                                        db.rollback()
                                        time.sleep(0.5)



                        row = cursor.fetchone()
                        if row != None:
                                row =dbcontrol.row_to_dict(cursor,row)
                                (sql,p) = self.get_markjob_sql(row)
#                               sql = "UPDATE %s SET sched=NULL WHERE url=%s" % (self.db_table,"%s")
                                cursor.execute(sql,p)
        
                        db.commit()
                        return row

                finally:
                        cursor.close()
                        self.db_pool.free_conn(db)



        def process_nextjob(self):
                return False
        
        def run(self):
                while True:
                        rc = self.process_nextjob()
                        if rc == False:
                                time.sleep(1)
                        else:   
                                time.sleep(0.01)

                        # return if the main thread has finished
                        en = threading.enumerate()
                        if not en[0].is_alive():
                                return






                row = self.get_nextjob()