Changeset 1204 for obs/repo-status

Timestamp:

Nov 29, 2015, 9:17:37 PM (8 years ago)

Author:

joergs

Message:

refactoring: move obs functionality to ObsStatus class

File:

• obs/repo-status/repo-status.py (modified) (8 diffs)

obs/repo-status/repo-status.py

@@ -32 +32 @@
     succeeded="SUCCEEDED"
 
-obs_status={
-    'status': STATE.unknown,
-    'broken': [],
-    'building': [],
-    'disabled': [],
-    'failed': [],
-    'finished': [],
-    'other': [],
-    'unresolvable': [],
-}
-
-version = {
-        'srcmd5': "",
-        'version': "",
-        'rev':     -1,
-        'time':   "",
-}
 
 jenkins_status = {
@@ -70 +53 @@
             print " ", i
 
-def write_status( obs_status, jenkins_status, version = {} ):
+def write_status(obs, jenkins_status):
     filename = "status.succeeded"
     status = STATE.succeeded
     component=""
-    if obs_status['status'] != STATE.succeeded and obs_status['status'] != STATE.disabled:
+    if obs.get_state() != STATE.succeeded and obs.get_state() != STATE.disabled:
         component = "obs"
-        status = obs_status['status']
+        status = obs.get_state()
     elif jenkins_status['status'] != STATE.succeeded and jenkins_status['status'] != STATE.disabled:
         component = "jenkins"
@@ -86 +69 @@
     if destdir:
         filepath=destdir + "/" + filename
-        out=open( filepath, 'w')
-        logger.info( "status will be written to " + filepath )
+        out=open(filepath, 'w')
+        logger.info("status will be written to " + filepath)
         # remove outdated files
-        for i in glob( destdir + "/status*" ):
-            if not os.path.samefile( i, filepath ):
-                logger.debug( "remove outdated status file " + i )
+        for i in glob(destdir + "/status*"):
+            if not os.path.samefile(i, filepath):
+                logger.debug("remove outdated status file " + i)
                 os.remove(i)
     else:
@@ -100 +83 @@
     out.write( "#\n" )
     out.write( "NAME="+filename+"\n" )
+    obs_status = obs.get_status()
     for key in sorted(obs_status):
         out.write( "#\n" )
@@ -105 +89 @@
             out.write( "OBS_STATUS" +"="+ obs_status[key] +"\n" )
         else:
-            out.write( "OBS_STATUS_" + key.upper() +"="+",".join(get_repo_list( obs_status[key] ))+"\n" )
+            out.write( "OBS_STATUS_" + key.upper() +"="+",".join(get_repo_list(obs_status[key]))+"\n" )
 
     out.write( "#\n" )
+    version = obs.get_pkg_info()
     for key in sorted(version):
         out.write( "BUILD_" + key.upper() +"="+str(version[key])+"\n")
+
+    out.write( "#\n" )
+    out.write("PACKAGES_SUCCESSFUL='%s'\n" % (get_packages_string(obs.get_successful_packages())))
+
+    out.write( "#\n" )
+    out.write("PACKAGES_FAILED='%s'\n" % (get_packages_string(obs.get_failed_packages())))
 
     out.write( "#\n" )
@@ -138 +129 @@
     return result
 
-
-def get_obs_results( prj, pkg ):
-    # get results of a project:
-    # %(repository)s|%(arch)s|%(state)s|%(dirty)s|%(code)s|%(details)s
-    # Debian_5.0|i586|published|False|succeeded|
-    # Debian_5.0|x86_64|published|False|succeeded|
-    cmd = format_command( [ osc, osc_paramter, "results", "--csv", "--format='%(state)s|%(repository)s|%(arch)s|%(dirty)s|%(code)s|%(details)s'", "--verbose", prj, pkg ] )
-    # "--last-build": NO, because if --last-build, disabled in 'code' is replaced by succeeded/failed
-    results=subprocess.Popen( cmd, stdout=subprocess.PIPE)
-    rc=results.wait()
-    if rc != 0:
-        logger.error( "failed to get osc results: " + str(rc) )
-        exit( rc )
-
-    reader = DictReader(results.stdout,
-                        delimiter='|',
-                        fieldnames=['state', 'repository',
-                                    'arch', 'dirty', 
-                                    'code', 'details'])
-    return reader
-
-
-def get_obs_last_build( prj, pkg, repository, arch ):
-    # {'rev': '99', 'version': '1.2.1170-1.3', 'srcmd5': '611f626d431d06dc81a32e0e021da0d7', 'time': '2014-03-12 16:43:55'}
-    cmd = format_command( [ osc, osc_paramter, "buildhist", "--csv", prj, pkg, repository, arch ] )
-    buildhist=subprocess.Popen( cmd, stdout=subprocess.PIPE )
-    rc=buildhist.wait()
-    reader={}
-    if rc != 0:
-        logger.error( "failed: " + rc )
-    else:
-        buildhist2 = subprocess.Popen(['tail', '-n', '1'],
-                        stdin=buildhist.stdout,
-                        stdout=subprocess.PIPE,
-                        )
-        reader = DictReader(buildhist2.stdout,
-                        delimiter='|',
-                        fieldnames=['time', 'srcmd5', 'rev', 'version'])
-    try:
-        # there should only be one entry
-        return reader.next()
-    except StopIteration:
-        return
-
-def get_obs_prj_results(project_name):
-    cmd = format_command( [ osc, osc_paramter, "results", "--xml", project_name ] )
-    # "--last-build": NO, because if --last-build, disabled in 'code' is replaced by succeeded/failed
-    results=subprocess.Popen(cmd, stdout=subprocess.PIPE)
-    #rc=results.wait()
-    (xmldata, stderr) = results.communicate()
-    rc=results.returncode
-    #logger.debug("rc: " + str(rc))
-    if rc != 0:
-        logger.error("failed to get osc results: " + str(rc))
-        exit(rc)
-    prj = {}
-    #root = etree.parse(xmldata).getroot()
-    root = etree.fromstring(xmldata)
-    #print etree.dump(root)
-    for result in root.getiterator('result'):
-        #print result.attrib
-        #print result.attrib['repository'], result.attrib['arch']
-        dist = get_repo_name(result.attrib['repository'], result.attrib['arch'], jenkins=True)
-        prj[dist] = []
-        for status in result.getiterator('status'):
-            #print status.attrib
-            if status.attrib['code'] == 'succeeded':
-                prj[dist].append(status.attrib['package'])
-            elif status.attrib['code'] == 'disabled':
-                pass
+def get_packages_string(packages):
+    pkg = ''
+    for dist in packages:
+        pkg += '%s:%s\n' % (dist, ','.join(packages[dist]))
+    return pkg
+
+class ObsStatus:
+    def __init__(self, prj, pkg):
+        self.logger = logging.getLogger()
+        self.prj = prj
+        self.pkg = pkg
+        self.state = STATE.unknown
+        self.status = {
+            'broken': [],
+            'building': [],
+            'disabled': [],
+            'failed': [],
+            'finished': [],
+            'other': [],
+            'unresolvable': [],
+        }
+        self.pkg_info = {
+            'srcmd5': "",
+            'version': "",
+            'rev':     -1,
+            'time':   "",
+        }
+        self.packages_successful = {}
+        self.packages_failed = {}
+
+    #def get_repo_name(self, repository, arch):
+        #return get_repo_name(repository, arch, jenkins=False):
+
+    def __get_obs_results(self):
+        # get results of a project:
+        # %(repository)s|%(arch)s|%(state)s|%(dirty)s|%(code)s|%(details)s
+        # Debian_5.0|i586|published|False|succeeded|
+        # Debian_5.0|x86_64|published|False|succeeded|
+        cmd = format_command( [ osc, osc_paramter, "results", "--csv", "--format='%(state)s|%(repository)s|%(arch)s|%(dirty)s|%(code)s|%(details)s'", "--verbose", self.prj, self.pkg ] )
+        # "--last-build": NO, because if --last-build, disabled in 'code' is replaced by succeeded/failed
+        results=subprocess.Popen( cmd, stdout=subprocess.PIPE)
+        rc=results.wait()
+        if rc != 0:
+            logger.error( "failed to get osc results: " + str(rc) )
+            exit( rc )
+
+        reader = DictReader(results.stdout,
+                            delimiter='|',
+                            fieldnames=['state', 'repository',
+                                        'arch', 'dirty', 
+                                        'code', 'details'])
+        return reader
+
+
+    def __get_obs_last_build(self, repository, arch):
+        # {'rev': '99', 'version': '1.2.1170-1.3', 'srcmd5': '611f626d431d06dc81a32e0e021da0d7', 'time': '2014-03-12 16:43:55'}
+        cmd = format_command( [ osc, osc_paramter, "buildhist", "--csv", self.prj, self.pkg, repository, arch ] )
+        buildhist=subprocess.Popen( cmd, stdout=subprocess.PIPE )
+        rc=buildhist.wait()
+        reader={}
+        if rc != 0:
+            logger.error( "failed: " + rc )
+        else:
+            buildhist2 = subprocess.Popen(['tail', '-n', '1'],
+                            stdin=buildhist.stdout,
+                            stdout=subprocess.PIPE,
+                            )
+            reader = DictReader(buildhist2.stdout,
+                            delimiter='|',
+                            fieldnames=['time', 'srcmd5', 'rev', 'version'])
+        try:
+            # there should only be one entry
+            return reader.next()
+        except StopIteration:
+            return
+
+
+    def __update_packages(self):
+        cmd = format_command( [ osc, osc_paramter, "results", "--xml", self.prj ] )
+        # "--last-build": NO, because if --last-build, disabled in 'code' is replaced by succeeded/failed
+        results=subprocess.Popen(cmd, stdout=subprocess.PIPE)
+        #rc=results.wait()
+        (xmldata, stderr) = results.communicate()
+        rc=results.returncode
+        if rc != 0:
+            logger.error("failed to get osc results: " + str(rc))
+            return False
+        #root = etree.parse(xmldata).getroot()
+        root = etree.fromstring(xmldata)
+        #print etree.dump(root)
+        for result in root.getiterator('result'):
+            #print result.attrib
+            #print result.attrib['repository'], result.attrib['arch']
+            dist = get_repo_name(result.attrib['repository'], result.attrib['arch'], jenkins=True)
+            self.packages_successful[dist] = []
+            self.packages_failed[dist] = []
+            for status in result.getiterator('status'):
+                #print status.attrib
+                if status.attrib['code'] == 'succeeded':
+                    self.packages_successful[dist].append(status.attrib['package'])
+                elif status.attrib['code'] == 'disabled':
+                    pass
+                else:
+                    logger.error("%s %s (%s) = %s" % (self.prj, status.attrib['package'], result.attrib['repository'], status.attrib['code']))
+                    self.packages_failed[dist].append(status.attrib['package'])
+            # if no failed packages are added to the dist, remove the dist
+            if not self.packages_failed[dist]:
+                del(self.packages_failed[dist])
+        return True
+
+
+    def __update_status(self):
+        obs_results=self.__get_obs_results()
+
+        for i in obs_results:
+            logger.debug( i )
+            if i['state'] == 'published' and i['dirty'] == 'False' and i['code'] == 'succeeded':
+                self.status['finished'].append(i)
+            elif i['state'] == 'building':
+                self.status['building'].append(i)
+            elif i['code'] == 'disabled':
+                self.status['disabled'].append(i)
+            elif i['code'] == 'failed':
+                self.status['failed'].append(i)
+            elif i['code'] == 'broken':
+                self.status['broken'].append(i)
+            elif i['code'] == 'unresolvable':
+                self.status['unresolvable'].append(i)
             else:
-                logger.error("%s %s (%s) = %s" % (project_name, status.attrib['package'], result.attrib['repository'], status.attrib['code']))
-                exit(1)
-    return prj
-
-
-def check_obs_status():
-    obs_results=get_obs_results( prj, pkg )
-
-    for i in obs_results:
-        logger.debug( i )
-        if i['state'] == 'published' and i['dirty'] == 'False' and i['code'] == 'succeeded':
-            obs_status['finished'].append(i)
-        elif i['state'] == 'building':
-            obs_status['building'].append(i)
-        elif i['code'] == 'disabled':
-            obs_status['disabled'].append(i)
-        elif i['code'] == 'failed':
-            obs_status['failed'].append(i)
-        elif i['code'] == 'broken':
-            obs_status['broken'].append(i)
-        elif i['code'] == 'unresolvable':
-            obs_status['unresolvable'].append(i)
+                self.status['other'].append(i)
+        return True
+
+
+    def __update_pkg_info(self):
+        rv=[]
+        # get max 'rev' and 'time' from finished builds
+        for i in self.status['finished']:
+            last_build=self.__get_obs_last_build(i['repository'], i['arch'])
+            self.logger.debug( str(last_build) )
+            #rv.append( dict(i.items() + j.items() ) )
+            if last_build:
+                rev=int(last_build['rev'])
+                time=last_build['time'].replace(" ","_")
+                if ( rev > self.pkg_info['rev'] ) or ( rev == self.pkg_info['rev'] and time > self.pkg_info['time'] ):
+                        self.pkg_info['rev'] = rev
+                        self.pkg_info['time'] = time
+                        self.pkg_info['srcmd5'] = last_build['srcmd5']
+                        self.pkg_info['version'] = last_build['version']
+                rv.append( { 'result': i, 'buildhist': last_build  } )
+            else:
+                self.logger.warn( "no buildhistory definied for " + i['repository'] + "-" + i['arch'] )
+        self.logger.debug( "result (max): " + str(self.pkg_info) )
+
+        for i in rv:
+            if int(i['buildhist']['rev']) != self.pkg_info['rev']:
+                self.logger.error( "UNKNOWN: " + pformat( i ) )
+        self.logger.debug( "finished:" )
+        for i in rv:
+            if int(i['buildhist']['rev']) == self.pkg_info['rev']:
+                self.logger.debug( pformat( i ) )
+        return True
+
+
+    def __update_state(self):
+        if self.status['building'] or self.status['other']:
+            self.state = STATE.pending
+        elif self.status['failed'] or self.status['broken'] or self.status['unresolvable'] or self.packages_failed:
+            self.state = STATE.failed
         else:
-            obs_status['other'].append(i)
-
-    if obs_status['building'] or obs_status['other']:
-        obs_status['status'] = STATE.pending
-        #return obs_status['status']
-    elif obs_status['failed'] or obs_status['broken'] or obs_status['unresolvable']:
-        obs_status['status'] = STATE.failed
-        #return obs_status['status']
-    else:
-        obs_status['status'] = STATE.succeeded
-
-    # else: all builds should be finished
-
-    rv=[]
-    for i in obs_status['finished']:
-        last_build=get_obs_last_build( prj, pkg, i['repository'], i['arch'] )
-        logger.debug( str(last_build) )
-        #rv.append( dict(i.items() + j.items() ) )
-        if last_build:
-            rev=int(last_build['rev'])
-            time=last_build['time'].replace(" ","_")
-            if ( rev > version['rev'] ) or ( rev == version['rev'] and time > version['time'] ):
-                    version['rev'] = rev
-                    version['time'] = time
-                    version['srcmd5'] = last_build['srcmd5']
-                    version['version'] = last_build['version']
-            rv.append( { 'result': i, 'buildhist': last_build  } )
+            self.state = STATE.succeeded
+        return True
+
+
+    def update(self):
+        self.__update_status()
+        self.__update_packages()
+        self.__update_pkg_info()
+        self.__update_state()
+        return True
+
+    def get_state(self):
+        return self.state
+    
+    def get_status(self, statustype=None):
+        result = None
+        if statustype == None:
+            result = self.status
         else:
-            logger.warn( "no buildhistory definied for " + i['repository'] + "-" + i['arch'] )
-
-    logger.debug( "result (max): " + str(version) )
-
-    for i in rv:
-        if int(i['buildhist']['rev']) != version['rev']:
-            logger.error( "UNKNOWN: " + pformat( i ) )
-
-    logger.debug( "finished:" )
-    for i in rv:
-        if int(i['buildhist']['rev']) == version['rev']:
-            logger.debug( pformat( i ) )
-
-    return obs_status['status']
+            result = self.status[statustype]
+        return result
+    
+    def get_pkg_info(self):
+        return self.pkg_info
+    
+    def get_pkg_version(self):
+        return self.pkg_info['version']
+    
+    def get_successful_packages(self):
+        return self.packages_successful
+
+    def get_failed_packages(self):
+        return self.packages_failed
+
+
 
 def add_jenkins_build_parameter( xmlConfig, build_params_add ):
@@ -414 +473 @@
     #etree.dump( xmlConfig )
 
-    pkg = ''
-    for dist in project_packages:
-        pkg += '%s:%s\n' % (dist, ','.join(project_packages[dist]))
-        #build_params['PACKAGES_' + dist] = ','.join(project_packages[dist])
+    pkg = get_packages_string(project_packages)
     build_params={ 'BUILD_VERSION': version['version'], 'BUILD_REV': version['rev'], 'BUILD_SRCMD5': version['srcmd5'], 'PACKAGES': pkg }
     # build paramter that must be present as Jenkins parameter configuration
@@ -500 +556 @@
 
     # check obs
-    if check_obs_status() == STATE.succeeded and version['version']:
+    obs = ObsStatus(prj, pkg)
+    obs.update()
+    if obs.get_state() == STATE.succeeded and obs.get_pkg_version():
         if args.jenkinsurl and args.jenkinsjob:
-            project_packages = get_obs_prj_results(prj)
             # run and check jenkins
-            check_jenkins_status(args.jenkinsurl, args.jenkinsjob, jenkins_status, get_repo_list( obs_status['finished'], jenkins=True ), version, project_packages)
+            check_jenkins_status(args.jenkinsurl, args.jenkinsjob, jenkins_status, get_repo_list( obs.get_status('finished'), jenkins=True ), obs.get_pkg_info(), obs.get_successful_packages())
     else:
         logger.info( "skipped jenkins tests, because prior steps" )
 
     logger.debug( "write status" )
-    write_status( obs_status, jenkins_status, version )
+    write_status(obs, jenkins_status)