openSUSE-release-tools/osc-staging.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# (C) 2013 mhrusecky@suse.cz, openSUSE.org
# (C) 2013 tchvatal@suse.cz, openSUSE.org
# Distribute under GPLv2 or GPLv3

from osc import cmdln
from osc import conf
from osc import commandline

OSC_STAGING_VERSION='0.0.1'

def _print_version(self):
    """ Print version information about this extension. """
    print '%s'%(self.OSC_STAGING_VERSION)
    quit(0)

# Get last build results (optionally only for specified repo/arch)
# Works even when rebuild is triggered
def _get_build_res(opts, prj, repo=None, arch=None):
    query = {}
    query['lastbuild'] = 1
    if repo is not None:
        query['repository'] = repo
    if arch is not None:
        query['arch'] = arch
    u = makeurl(opts.apiurl, ['build', prj, '_result'], query=query)
    f = http_GET(u)
    return f.readlines()

def _get_changed(opts, project, everything):
    ret = []
    # Check for local changes
    for pkg in meta_get_packagelist(opts.apiurl, project):
        if len(ret) != 0 and not everything:
            break
        f = http_GET(makeurl(opts.apiurl, ['source', project, pkg]))
        linkinfo = ET.parse(f).getroot().find('linkinfo')
        if linkinfo is None:
            ret.append({'pkg': pkg, 'code': 'NOT_LINK', 'msg': 'Not a source link'})
            continue
        if linkinfo.get('error'):
            ret.append({'pkg': pkg, 'code': 'BROKEN', 'msg': 'Broken source link'})
            continue
        t = linkinfo.get('project')
        p = linkinfo.get('package')
        r = linkinfo.get('revision')
        if len(server_diff(opts.apiurl, t, p, r, project, pkg, None, True)) > 0:
            ret.append({'pkg': pkg, 'code': 'MODIFIED', 'msg': 'Has local modifications', 'pprj': t, 'ppkg': p})
            continue
    return ret


# Checks the state of staging repo (local modifications, regressions, ...)
def _staging_check(self, project, check_everything, opts):
    """
    Checks whether project does not contain local changes
    and whether it contains only links
    :param project: staging project to check
    :param everything: do not stop on first verification failure
    :param opts: pointer to options
    """

    ret = 0
    chng = _get_changed(opts.apiurl, project, check_everything)
    if len(chng) > 0:
        for pair in chng:
            print >>sys.stderr, 'Error: Package "%s": %s'%(pair['pkg'],pair['msg'])
        print >>sys.stderr, "Error: Check for local changes failed"
        ret = 1
    else:
        print "Check for local changes passed"

    # Check for regressions
    root = None
    if ret == 0 or check_everything:
        print "Getting build status, this may take a while"
        # Get staging project results
        f = _get_build_res(opts.apiurl, project)
        root = ET.fromstring(''.join(f))

        # Get parent project
        m_url = make_meta_url("prj", project, opts.apiurl)
        m_data = http_GET(m_url).readlines()
        m_root = ET.fromstring(''.join(m_data))

        print "Comparing build statuses, this may take a while"

    # Iterate through all repos/archs
    if root is not None and root.find('result') is not None:
        for results in root.findall('result'):
            if ret != 0 and not check_everything:
                break
            if results.get("state") not in [ "published", "unpublished" ]:
                print >>sys.stderr, "Warning: Building not finished yet for %s/%s (%s)!"%(results.get("repository"),results.get("arch"),results.get("state"))
                ret |= 2

            # Get parent project results for this repo/arch
            p_project = m_root.find("repository[@name='%s']/path"%(results.get("repository")))
            if p_project == None:
                print >>sys.stderr, "Error: Can't get path for '%s'!"%results.get("repository")
                ret |= 4
                continue
            f = _get_build_res(opts.apiurl, p_project.get("project"), repo=results.get("repository"), arch=results.get("arch"))
            p_root = ET.fromstring(''.join(f))

            # Find corresponding set of results in parent project
            p_results = p_root.find("result[@repository='%s'][@arch='%s']"%(results.get("repository"),results.get("arch")))
            if p_results == None:
                print >>sys.stderr, "Error: Inconsistent setup!"
                ret |= 4
            else:
                # Iterate through packages
                for node in results:
                    if ret != 0 and not check_everything:
                        break
                    result = node.get("code")
                    # Skip not rebuilt
                    if result in [ "blocked", "building", "disabled" "excluded", "finished", "unknown", "unpublished", "published" ]:
                        continue
                    # Get status of package in parent project
                    p_node = p_results.find("status[@package='%s']"%(node.get("package")))
                    if p_node == None:
                        p_result = None
                    else:
                        p_result = p_node.get("code")
                    # Skip packages not built in parent project
                    if p_result in [ None, "disabled", "excluded", "unknown", "unresolvable" ]:
                        continue
                    # Find regressions
                    if result in [ "broken", "failed", "unresolvable" ] and p_result not in [ "blocked", "broken", "failed" ]:
                        print >>sys.stderr, "Error: Regression (%s -> %s) in package '%s' in %s/%s!"%(p_result, result, node.get("package"),results.get("repository"),results.get("arch"))
                        ret |= 8
                    # Find fixed builds
                    if result in [ "succeeded" ] and result != p_result:
                        print "Package '%s' fixed (%s -> %s) in staging for %s/%s."%(node.get("package"), p_result, result, results.get("repository"),results.get("arch"))

    if ret != 0:
        print "Staging check failed!"
    else:
        print "Staging check succeeded!"
    return ret

def _staging_create(self, trg, opts):
    """
    Creates new staging project based on the submit request.
    :param trg: submit request to create staging project for or parent project/package
    :param opts: pointer to options
    """

    req = None

    # We are dealing with sr
    if re.match('^\d+$', trg):
        # read info from sr
        req = get_request(opts.apiurl, trg)
        act = req.get_actions("submit")[0]

        trg_prj = act.tgt_project
        trg_pkg = act.tgt_package
        src_prj = act.src_project
        src_pkg = act.src_package

    # We are dealing with project
    else:
        data = re.split('/', trg)
        o_stg_prj = data[0]
        trg_prj = re.sub(':Staging:.*','',data[0])
        src_prj = re.sub(':Staging:.*','',data[0])
        if len(data)>1:
            trg_pkg = data[1]
            src_pkg = data[1]
        else:
            trg_pkg = None
            src_pkg = None

    # Set staging name and maybe parent
    if trg_pkg is not None:
        stg_prj = trg_prj + ":Staging:" + trg_pkg

    if re.search(':Staging:',trg):
        stg_prj = o_stg_prj

    if opts.parent:
        trg_prj = opts.parent

    # test if staging project exists
    found = 1
    url = make_meta_url('prj', stg_prj, opts.apiurl)
    try:
       data = http_GET(url).readlines()
    except HTTPError as e:
       if e.code == 404:
            found = 0
       else:
            raise e
    if found == 1:
        print('Staging project "%s" already exists, overwrite? (Y/n)'%(stg_prj))
        answer = sys.stdin.readline()
        if re.search("^\s*[Nn]", answer):
            print('Aborting...')
            exit(1)
 
    # parse metadata from parent project
    trg_meta_url = make_meta_url("prj", trg_prj, opts.apiurl)
    data = http_GET(trg_meta_url).readlines()

    dis_repo = []
    en_repo = []
    repos = []
    perm =''
    in_build = 0
    for line in data:
        # what repositories are disabled
        if in_build == 1:
            if re.search("^\s+</build>", line):
                in_build = 0
            elif re.search("^\s+<disable", line):
                dis_repo.append(re.sub(r'.*repository="([^"]+)".*', r'\1', line).strip())
            elif re.search("^\s+<enable", line):
                en_repo.append(re.sub(r'.*repository="([^"]+)".*', r'\1', line).strip())
        elif re.search("^\s+<build>", line):
            in_build=1
        # what are the rights
        elif re.search("^\s+(<person|<group)", line):
                perm += line
        # what are the repositories
        elif re.search("^\s+<repository", line):
                repos.append(re.sub(r'.*name="([^"]+)".*', r'\1', line).strip())
   
    # add maintainers of source project
    trg_meta_url = make_meta_url("prj", src_prj, opts.apiurl)
    data = http_GET(trg_meta_url).readlines()
    perm += "".join(filter((lambda x: (re.search("^\s+(<person|<group)", x) is not None)), data))
    
    # add maintainers of source package
    if src_pkg is not None:
        trg_meta_url = make_meta_url("pkg", (src_prj, src_pkg), opts.apiurl)
        data = http_GET(trg_meta_url).readlines()
        perm += "".join(filter((lambda x: (re.search("^\s+(<person|<group)", x) is not None)), data))

    # create xml for new project
    new_xml  = '<project name="%s">\n'%(stg_prj)
    if req is not None:
        new_xml += '  <title>Staging project for package %s (sr#%s)</title>\n'%(trg_pkg, req.reqid)
    else:
        new_xml += '  <title>Staging project "%s"</title>\n'%(trg)
    new_xml += '  <description></description>\n'
    new_xml += '  <link project="%s"/>\n'%(trg_prj)
    if req is not None:
        new_xml += '  <person userid="%s" role="maintainer"/>\n'%(req.get_creator())
    new_xml += perm
    new_xml += '  <build><enable/></build>\n'
    new_xml += '  <debuginfo><enable/></debuginfo>\n'
    new_xml += '  <publish><disable/></publish>\n'
    for repo in repos:
        if repo not in dis_repo:
            new_xml += '  <repository name="%s" rebuild="direct" linkedbuild="localdep">\n'%(repo)
            new_xml += '    <path project="%s" repository="%s"/>\n'%(trg_prj,repo)
            new_xml += '    <arch>i586</arch>\n'
            new_xml += '    <arch>x86_64</arch>\n'
            new_xml += '  </repository>\n'
    new_xml += '</project>\n'

    # creation of new staging project
    print('Creating staging project "%s"...'%(stg_prj))
    url = make_meta_url('prj',stg_prj,opts.apiurl,True,False)
    f = metafile(url, new_xml, False)
    http_PUT(f.url, file=f.filename)

    # link package there
    if src_pkg is not None and trg_pkg is not None:
        print('Linking package %s/%s -> %s/%s...'%(src_pkg,src_prj,stg_prj,trg_pkg))
        link_pac(src_prj, src_pkg, stg_prj, trg_pkg, True)
    print
    
    return

def _staging_remove(self, project, opts):
    """
    Remove staging project.
    :param project: staging project to delete
    :param opts: pointer to options
    """
    chng = _get_changed(opts, project, True)
    if len(chng) > 0:
        print('Staging project "%s" is not clean:'%(project))
        print('')
        for pair in chng:
            print(' * %s : %s'%(pair['pkg'],pair['msg']))
        print('')
        print('Really delete? (N/y)')
        answer = sys.stdin.readline()
        if not re.search("^\s*[Yy]", answer):
            print('Aborting...')
            exit(1)
    delete_project(opts.apiurl, project, force=True, msg=None)
    print("Deleted.")
    return

def _staging_submit_devel(self, project, opts):
    """
    Generate new review requests for devel-projects based on our staging changes.
    :param project: staging project to submit into devel projects
    """
    chng = _get_changed(opts, project, True)
    msg = "Fixes from staging project %s" % project
    if opts.message is not None:
        msg = opts.message
    if len(chng) > 0:
        for pair in chng:
            if pair['code'] != 'MODIFIED':
                print >>sys.stderr, 'Error: Package "%s": %s'%(pair['pkg'],pair['msg'])
            else:
                print('Sending changes back %s/%s -> %s/%s'%(project,pair['pkg'],pair['pprj'],pair['ppkg']))
                action_xml  = '<request>';
                action_xml += '   <action type="submit"> <source project="%s" package="%s" /> <target project="%s" package="%s" />' % (project, pair['pkg'], pair['pprj'], pair['ppkg'])
                action_xml += '   </action>'
                action_xml += '   <state name="new"/> <description>%s</description>' % msg
                action_xml += '</request>'

                u = makeurl(opts.apiurl, ['request'], query='cmd=create&addrevision=1')
                f = http_POST(u, data=action_xml)

                root = ET.parse(f).getroot()
                print("Created request %s" % (root.get('id')))
    else:
        print("No changes to submit")
    return

def _staging_change_review_state(self, opts, id, newstate, by_group='', by_user='', message='', supersed=None):
    """ taken from osc/osc/core.py, improved:
        - verbose option added,
        - empty by_user=& removed.
        - numeric id can be int().
    """
    query = {'cmd': 'changereviewstate', 'newstate': newstate }
    if by_group:  query['by_group'] = by_group
    if by_user:   query['by_user'] = by_user
    if supersed: query['superseded_by'] = supersed
#    if message: query['comment'] = message
    u = makeurl(opts.apiurl, ['request', str(id)], query=query)
    f = http_POST(u, data=message)
    root = ET.parse(f).getroot()
    return root.attrib['code']

def _staging_get_rings(self, opts):
    ret = dict()
    for prj in ['openSUSE:Factory:Build', 'openSUSE:Factory:Core', 'openSUSE:Factory:MainDesktops', 'openSUSE:Factory:DVD']:
        u = makeurl(opts.apiurl, ['source', prj])
        f = http_GET(u)
        for entry in ET.parse(f).getroot().findall('entry'):
            ret[entry.attrib['name']] = prj
    return ret

def _staging_one_request(self, rq, opts):
    if (opts.verbose):
        ET.dump(rq)
        print(opts)
    id = int(rq.get('id'))
    act_id = 0
    approved_actions = 0
    actions = rq.findall('action')
    act = actions[0]
        
    tprj = act.find('target').get('project')
    tpkg = act.find('target').get('package')

    e = []
    if not tpkg:
        e.append('no target/package in request %d, action %d; ' % (id, act_id))
    if not tprj:
        e.append('no target/project in request %d, action %d; ' % (id, act_id))
    # it is no error, if the target package dies not exist

    ring = self.rings.get(tpkg, None)
    if ring is None or ring == 'openSUSE:Factory:DVD' or ring == 'openSUSE:Factory:MainDesktops':
        msg = "ok"
    else:
        stage_info = self.packages_staged.get(tpkg, ('', 0))
        if stage_info[0] == self.letter_to_accept and int(stage_info[1]) == id:
            stprj = 'openSUSE:Factory:Staging:%s' % self.letter_to_accept
            msg = 'ok, tested in %s' % stprj
            delete_package(opts.apiurl, stprj, tpkg, msg='done')
        elif stage_info[1] != 0 and int(stage_info[1]) != id:
	    print stage_info
            print "osc rqlink %s openSUSE:Factory:Staging:%s" % (id, stage_info[0])
	    return
        elif stage_info[1] != 0: # keep silent about those already asigned
            return
        else:
            print "Request(%d): %s -> %s" % (id, tpkg, ring)
	    print "osc rqlink %s openSUSE:Factory:Staging:" % id
            return

    self._staging_change_review_state(opts, id, 'accepted', by_group='factory-staging', message=msg)

def _staging_parse_staging_prjs(self, opts):
    self.packages_staged = dict()

    for letter in range(ord('A'), ord('J')):
        prj = "openSUSE:Factory:Staging:%s" % chr(letter)
        u = makeurl(opts.apiurl, ['source', prj, '_meta'])
        f = http_GET(u)
        title = ET.parse(f).getroot().find('title').text
        if title is None: continue
        for rq in title.split(','):
            m = re.match(r" *([\w-]+)\((\d+)\)", rq)
            if m is None: continue
            self.packages_staged[m.group(1)] = (chr(letter), m.group(2))

def _staging_check_one_source(self, flink, si, opts):
    package = si.get('package')
    # we have to check if its a link within the staging project
    # in this case we need to keep the link as is, and not freezing
    # the target. Otherwise putting kernel-source into staging prj
    # won't get updated kernel-default (and many other cases)
    for linked in si.findall('linked'):
        if linked.get('project') in self.projectlinks:
            # take the unexpanded md5 from Factory link
            url = makeurl(opts.apiurl, ['source', 'openSUSE:Factory', package], { 'view': 'info' })
            #print package, linked.get('package'), linked.get('project')
            f = http_GET(url)
            proot = ET.parse(f).getroot()
            ET.SubElement(flink, 'package', { 'name': package, 'srcmd5': proot.get('lsrcmd5'), 'vrev': si.get('vrev') })
            return package
    ET.SubElement(flink, 'package', { 'name': package, 'srcmd5': si.get('srcmd5'), 'vrev': si.get('vrev') })
    return package

def _staging_receive_sources(self, prj, sources, flink, opts):
    url = makeurl(opts.apiurl, ['source', prj], { 'view': 'info' } )
    f = http_GET(url)
    root = ET.parse(f).getroot()

    for si in root.findall('sourceinfo'):
        package = self._staging_check_one_source(flink, si, opts)
        sources[package] = 1
    return sources

def _staging_freeze_prjlink(self, prj, opts):
    url = makeurl(opts.apiurl, ['source', prj, '_meta'])
    f = http_GET(url)
    root = ET.parse(f).getroot()
    sources = dict()
    flink = ET.Element('frozenlinks')
    links = root.findall('link')
    links.reverse()
    self.projectlinks = []
    for link in links:
        self.projectlinks.append(link.get('project'))

    for lprj in self.projectlinks:
        fl = ET.SubElement(flink, 'frozenlink', { 'project': lprj } )
        sources = self._staging_receive_sources(lprj, sources, fl, opts)
    
    from pprint import pprint
    url = makeurl(opts.apiurl, ['source', prj, '_project', '_frozenlinks'], { 'meta': '1' } )
    f = http_PUT(url, data=ET.tostring(flink))
    root = ET.parse(f).getroot()
    print ET.tostring(root)

def _staging_cleanup_rings(self, opts):
    self.bin2src = dict()
    self.pkgdeps = dict()
    self.sources = list()
    self._staging_check_depinfo_ring('openSUSE:Factory:Build', 'openSUSE:Factory:Core', opts);
    self._staging_check_depinfo_ring('openSUSE:Factory:Core', 'openSUSE:Factory:MainDesktops', opts);

def _staging_fill_pkgdeps(self, prj, repo, arch, opts):
    url = makeurl(opts.apiurl, ['build', prj, repo, arch, '_builddepinfo'])
    f = http_GET(url)
    root = ET.parse(f).getroot()
    
    for package in root.findall('package'):
        #print ET.tostring(package)
        source = package.find('source').text
        if package.attrib['name'].startswith('preinstall'):
            continue
        self.sources.append(source)

        for subpkg in package.findall('subpkg'):
            subpkg = subpkg.text
            if self.bin2src.has_key(subpkg):
                print "bin $s defined twice $prj $source - $bin2src{$s}\n"
            self.bin2src[subpkg] = source
        
    for package in root.findall('package'):
        source = package.find('source').text
        for pkg in package.findall('pkgdep'):
            if not self.bin2src.has_key(pkg.text):
                if pkg.text.startswith('texlive-'):
                    for letter in range(ord('a'), ord('z') + 1):
                        self.pkgdeps['texlive-specs-' + chr(letter)] = 'texlive-specs-' + chr(letter)
                else:
                    print "PKG NOT THERE", pkg.text
                continue
            b = self.bin2src[pkg.text]
            self.pkgdeps[b] = source

def _staging_check_depinfo_ring(self, prj, nextprj, opts):
  self._staging_fill_pkgdeps(prj, 'standard', 'x86_64', opts)

  if prj == 'openSUSE:Factory:Core':
      url = makeurl(opts.apiurl, ['build', prj, 'images', 'x86_64', 'Test-DVD-x86_64', '_buildinfo'] )
      root = ET.parse(http_GET(url)).getroot()
      for bdep in root.findall('bdep'):
          if not bdep.attrib.has_key('name'): continue
          b = bdep.attrib['name']
          if not self.bin2src.has_key(b): continue
          b = self.bin2src[b]
          self.pkgdeps[b] = 'MYdvd'

  # if ($prj eq 'openSUSE:Factory:MainDesktops') {
  #   $dinfo->{MYcds} = {};
  #   $dinfo->{MYcds}->{pkgdep} = ();
  #   $dinfo->{MYcds}->{source} = 'MYcds';
  #   push(@{$dinfo->{MYcds}->{pkgdep}}, 'kiwi-image-livecd-gnome');
  #   push(@{$dinfo->{MYcds}->{pkgdep}}, 'kiwi-image-livecd-kde');

  if prj == 'openSUSE:Factory:Build':
      url = makeurl(opts.apiurl, ['build', prj, 'standard', '_buildconfig'] )
      for line in http_GET(url).read().split('\n'):
          if line.startswith('Preinstall:') or line.startswith('Support:'):
              for prein in line.split(':')[1].split():
                  if not self.bin2src.has_key(prein): continue
                  b = self.bin2src[prein]
                  self.pkgdeps[b] = 'MYinstall'

  #print self.sources, self.pkgdeps, self.bin2src

  for source in self.sources:
      #   next if ($key =~ m/^MY/ || $key =~ m/^texlive-specs-/ || $key =~ m/^kernel-/);
      if not self.pkgdeps.has_key(source):
          print "PROBLEM", source
  #   if (!defined $pkgdeps{$source}) {
  #     print "osc rdelete -m cleanup $prj $key\n";
  #     if ($nextprj) {
  #       print "osc linkpac -c openSUSE:Factory $key $nextprj\n";
  #     }
  #   }
 

@cmdln.option('-e', '--everything', action='store_true', dest='everything',
              help='during check do not stop on first first issue and show them all')
@cmdln.option('-p', '--parent', metavar='TARGETPROJECT',
              help='manually specify different parent project during creation of staging')
@cmdln.option('-m', '--message', metavar='TEXT',
              help='manually specify different parent project during creation of staging')
@cmdln.option('-v', '--version', action='store_true',
              dest='version',
              help='show version of the plugin')
def do_staging(self, subcmd, opts, *args):
    """${cmd_name}: Commands to work with staging projects

    "check" will check if all packages are links without changes

    "create" (or "c") will create staging repo from specified submit request

    "remove" (or "r") will delete the staging project into submit requests for openSUSE:Factory

    "submit-devel" (or "s") will create review requests for changed packages in staging project
        into their respective devel projects to obtain approval from maitnainers for pushing the
        changes to openSUSE:Factory

    "freeze" will freeze the sources of the project's links (not affecting the packages actually in)
    
    "accept" will accept all requests openSUSE:Factory:Staging:<LETTER>

    "list" will pick the requests not in rings

    Usage:
        osc staging check [--everything] REPO
        osc staging create [--parent project] SR#
        osc staging create [--parent project] PROJECT[/PACKAGE]
        osc staging remove REPO
        osc staging submit-devel [-m message] REPO
        osc staging freeze PROJECT
        osc staging list
        osc staging accept LETTER
        osc staging cleanup_rings
    """
    if opts.version:
        self._print_version()

    # verify the argument counts match the commands
    cmd = args[0]
    if cmd in ['submit-devel', 's', 'remove', 'r', 'accept', 'freeze']:
        min_args, max_args = 1, 1
    elif cmd in ['check']:
        min_args, max_args = 1, 2
    elif cmd in ['create', 'c']:
        min_args, max_args = 1, 2
    elif cmd in ['list', 'cleanup_rings']:
        min_args, max_args = 0, 0
    else:
        raise RuntimeError('Unknown command: %s'%(cmd))
    if len(args) - 1 < min_args:
        raise oscerr.WrongArgs('Too few arguments.')
    if not max_args is None and len(args) - 1 > max_args:
        raise oscerr.WrongArgs('Too many arguments.')

    # init the obs access
    opts.apiurl = self.get_api_url()
    opts.verbose = False

    # check for the opts
    staging_check_everything = False
    if opts.everything:
        staging_check_everything = True

    self._staging_parse_staging_prjs(opts)
    self.rings = self._staging_get_rings(opts)

    # call the respective command and parse args by need
    if cmd in ['push', 'p']:
        project = args[1]
        self._staging_push(project, opts)
    elif cmd in ['create', 'c']:
        sr = args[1]
        self._staging_create(sr, opts)
    elif cmd in ['check']:
        project = args[1]
        return self._staging_check(project, staging_check_everything, opts)
    elif cmd in ['remove', 'r']:
        project = args[1]
        self._staging_remove(project, opts)
    elif cmd in ['submit-devel', 's']:
        project = args[1]
        self._staging_submit_devel(project, opts)
    elif cmd in ['freeze']:
        self._staging_freeze_prjlink(args[1], opts)
    elif cmd in ['cleanup_rings']:
        self._staging_cleanup_rings(opts)
    elif cmd in ['accept', 'list']:
        self.letter_to_accept = None
        if cmd == 'accept':
            self.letter_to_accept = args[1]

        # xpath query, using the -m, -r, -s options
        where = "@by_group='factory-staging'+and+@state='new'"

        url = makeurl(opts.apiurl, ['search','request'], "match=state/@name='review'+and+review["+where+"]")
        f = http_GET(url)
        root = ET.parse(f).getroot()
        for rq in root.findall('request'):
            tprj = rq.find('action/target').get('project')
            self._staging_one_request(rq, opts)

        if self.letter_to_accept:
            url = makeurl(opts.apiurl, ['source', 'openSUSE:Factory:Staging:%s' % self.letter_to_accept])
            f = http_GET(url)
            root = ET.parse(f).getroot()
            print ET.tostring(root)