5081

pending completion

Build # 5081

Build Type

Pull #2054

travis-ci

Committed by

web-flow

Commit Message

accept_command: fix missing the url for commenting

Regression from acc0ffc38 , we still need
url for commenting on the product package.

Pull Request Pull Request #2054: accept_command: fix missing the url for commenting

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

2519 of 14217 relevant lines covered (17.72%)

0.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

23.21

/osclib/accept_command.py

import re

try:
    from urllib.error import HTTPError
except ImportError:
    #python 2.x
    from urllib2 import HTTPError

import warnings
from xml.etree import cElementTree as ET

from osc.core import change_request_state, show_package_meta, wipebinaries
from osc.core import http_GET, http_PUT, http_DELETE, http_POST
from osc.core import delete_package, search, set_devel_project
from osclib.config_command import ConfigCommand
from osclib.core import attribute_value_save
from osclib.core import attribute_value_load
from osclib.core import source_file_load
from osclib.core import source_file_save
from datetime import date


class AcceptCommand(object):
    def __init__(self, api):
        self.api = api

    def find_new_requests(self, project):
        query = "match=state/@name='new'+and+action/target/@project='{}'".format(project)
        url = self.api.makeurl(['search', 'request'], query)

        f = http_GET(url)
        root = ET.parse(f).getroot()

        rqs = []
        for rq in root.findall('request'):
            pkgs = []
            act_type = None
            actions = rq.findall('action')
            for action in actions:
                act_type = action.get('type')
                targets = action.findall('target')
                for t in targets:
                    pkgs.append(str(t.get('package')))

            rqs.append({'id': int(rq.get('id')), 'packages': pkgs, 'type': act_type})
        return rqs

    def virtual_accept_request_has_no_binary(self, project, package):
        filelist = self.api.get_filelist_for_package(pkgname=package, project=self.api.project, expand='1', extension='spec')
        pkgs = self.api.extract_specfile_short(filelist)

        for pkg in pkgs:
            query = {'view': 'binarylist', 'package': pkg, 'multibuild': '1'}
            pkg_binarylist = ET.parse(http_GET(self.api.makeurl(['build', project, '_result'], query=query))).getroot()
            for binary in pkg_binarylist.findall('./result/binarylist/binary'):
                return False

        return True

    def find_virtually_accepted_requests(self, project):
        query = "match=state/@name='review'+and+(action/target/@project='{}'+and+action/@type='delete')+and+(review/@state='new'+and+review/@by_group='{}')".format(project, self.api.cdelreq_review)
        url = self.api.makeurl(['search', 'request'], query)

        f = http_GET(url)
        root = ET.parse(f).getroot()

        rqs = []
        for rq in root.findall('request'):
            pkgs = []
            actions = rq.findall('action')
            for action in actions:
                targets = action.findall('target')
                for t in targets:
                    pkgs.append(str(t.get('package')))

            rqs.append({'id': int(rq.get('id')), 'packages': pkgs})
        return rqs

    def reset_rebuild_data(self, project):
        data = self.api.pseudometa_file_load('support_pkg_rebuild')
        if data is None:
            return

        root = ET.fromstring(data)
        for stg in root.findall('staging'):
            if stg.get('name') == project:
                stg.find('rebuild').text = 'unknown'
                stg.find('supportpkg').text = ''

        # reset accpted staging project rebuild state to unknown and clean up
        # supportpkg list
        content = ET.tostring(root)
        if content != data:
            self.api.pseudometa_file_save('support_pkg_rebuild', content, 'accept command update')

    def virtually_accept_delete(self, request_id, package):
        self.api.add_review(request_id, by_group=self.api.cdelreq_review, msg='Request accepted. Cleanup in progress - DO NOT REVOKE!')

        filelist = self.api.get_filelist_for_package(pkgname=package, project=self.api.project, expand='1', extension='spec')
        pkgs = self.api.extract_specfile_short(filelist)

        # Disable build and wipes the binary to the package and the sub-package
        for pkg in pkgs:
            meta = show_package_meta(self.api.apiurl, self.api.project, pkg)
            meta = ''.join(meta)
            # Update package meta to disable build
            self.api.create_package_container(self.api.project, pkg, meta=meta, disable_build=True)
            wipebinaries(self.api.apiurl, self.api.project, package=pkg, repo=self.api.cmain_repo)

            # Remove package from Rings
            if self.api.ring_packages.get(pkg):
                delete_package(self.api.apiurl, self.api.ring_packages.get(pkg), pkg, force=True, msg="Cleanup package in Rings")

    def perform(self, project, force=False):
        """Accept the staging project for review and submit to Factory /
        openSUSE 13.2 ...

        Then disable the build to disabled
        :param project: staging project we are working with

        """

        status = self.api.check_project_status(project)

        if not status:
            print('The project "{}" is not yet acceptable.'.format(project))
            if not force:
                return False

        meta = self.api.get_prj_pseudometa(project)
        packages = []
        for req in meta['requests']:
            self.api.rm_from_prj(project, request_id=req['id'], msg='ready to accept')
            packages.append(req['package'])
            msg = 'Accepting staging review for {}'.format(req['package'])

            oldspecs = self.api.get_filelist_for_package(pkgname=req['package'],
                                                         project=self.api.project,
                                                         extension='spec')
            if 'type' in req and req['type'] == 'delete' and self.api.cdelreq_review:
                msg += ' and started handling of virtual accept process'
                print(msg)
                # Virtually accept the delete request
                self.virtually_accept_delete(req['id'], req['package'])
            else:
                print(msg)
                change_request_state(self.api.apiurl,
                                     str(req['id']),
                                     'accepted',
                                     message='Accept to %s' % self.api.project,
                                     force=force)
                self.create_new_links(self.api.project, req['package'], oldspecs)

        self.api.accept_status_comment(project, packages)
        self.api.staging_deactivate(project)
        ConfigCommand(self.api).perform([project], 'todo')

        return True

    def cleanup(self, project):
        if not self.api.item_exists(project):
            return False

        pkglist = self.api.list_packages(project)
        clean_list = set(pkglist) - set(self.api.cnocleanup_packages)

        for package in clean_list:
            print("[cleanup] deleted %s/%s" % (project, package))
            delete_package(self.api.apiurl, project, package, force=True, msg="autocleanup")

        # wipe Test-DVD binaries and breaks kiwi build
        if project.startswith('openSUSE:'):
            for package in pkglist:
                if package.startswith('Test-DVD-'):
                    # intend to break the kiwi file
                    arch = package.split('-')[-1]
                    fakepkgname = 'I-am-breaks-kiwi-build'
                    oldkiwifile = source_file_load(self.api.apiurl, project, package, 'PRODUCT-'+arch+'.kiwi')
                    if oldkiwifile is not None:
                        newkiwifile = re.sub(r'<repopackage name="openSUSE-release"/>', '<repopackage name="%s"/>' % fakepkgname, oldkiwifile)
                        source_file_save(self.api.apiurl, project, package, 'PRODUCT-' + arch + '.kiwi', newkiwifile)

                    # do wipe binary now
                    query = { 'cmd': 'wipe' }
                    query['package'] = package
                    query['repository'] = 'images'

                    url = self.api.makeurl(['build', project], query)
                    try:
                        http_POST(url)
                    except HTTPError as err:
                        # failed to wipe isos but we can just continue
                        pass

        return True

    def accept_other_new(self):
        changed = False

        if self.api.cdelreq_review:
            rqlist = self.find_virtually_accepted_requests(self.api.project)
            for req in rqlist:
                if self.virtual_accept_request_has_no_binary(self.api.project, req['packages'][0]):
                    # Accepting delreq-review review
                    self.api.do_change_review_state(req['id'], 'accepted',
                                                    by_group=self.api.cdelreq_review,
                                                    message='Virtually accepted delete {}'.format(req['packages'][0]))

        rqlist = self.find_new_requests(self.api.project)
        if self.api.cnonfree:
            rqlist += self.find_new_requests(self.api.cnonfree)

        for req in rqlist:
            oldspecs = self.api.get_filelist_for_package(pkgname=req['packages'][0], project=self.api.project, extension='spec')
            print('Accepting request %d: %s' % (req['id'], ','.join(req['packages'])))
            if req['type'] == 'delete':
                # Remove devel project/package tag before accepting the request
                self.remove_obsoleted_develtag(self.api.project, req['packages'][0])
            change_request_state(self.api.apiurl, str(req['id']), 'accepted', message='Accept to %s' % self.api.project)
            # Check if all .spec files of the package we just accepted has a package container to build
            self.create_new_links(self.api.project, req['packages'][0], oldspecs)
            changed = True

        return changed

    def remove_obsoleted_develtag(self, project, package):
        xpath = {
            'package': "@project='%s' and devel/@project=@project and devel/@package='%s'" % (project, package),
        }
        collection = search(self.api.apiurl, **xpath)['package']
        for pkg in collection.findall('package'):
            set_devel_project(self.api.apiurl, project, pkg.attrib['name'], devprj=None)

    def create_new_links(self, project, pkgname, oldspeclist):
        filelist = self.api.get_filelist_for_package(pkgname=pkgname, project=project, extension='spec')
        removedspecs = set(oldspeclist) - set(filelist)
        for spec in removedspecs:
            # Deleting all the packages that no longer have a .spec file
            url = self.api.makeurl(['source', project, spec[:-5]])
            print("Deleting package %s from project %s" % (spec[:-5], project))
            try:
                http_DELETE(url)
            except HTTPError as err:
                if err.code == 404:
                    # the package link was not yet created, which was likely a mistake from earlier
                    pass
                else:
                    # If the package was there bug could not be delete, raise the error
                    raise

            # Remove package from Rings in case 2nd specfile was removed
            if self.api.ring_packages.get(spec[:-5]):
                delete_package(self.api.apiurl, self.api.ring_packages.get(spec[:-5]), spec[:-5], force=True, msg="Cleanup package in Rings")

        if len(filelist) > 1:
            # There is more than one .spec file in the package; link package containers as needed
            origmeta = source_file_load(self.api.apiurl, project, pkgname, '_meta')
            for specfile in filelist:
                package = specfile[:-5]  # stripping .spec off the filename gives the packagename
                if package == pkgname:
                    # This is the original package and does not need to be linked to itself
                    continue
                # Check if the target package already exists, if it does not, we get a HTTP error 404 to catch
                if not self.api.item_exists(project, package):
                    print("Creating new package %s linked to %s" % (package, pkgname))
                    # new package does not exist. Let's link it with new metadata
                    newmeta = re.sub(r'(<package.*name=.){}'.format(pkgname),
                                     r'\1{}'.format(package),
                                     origmeta)
                    newmeta = re.sub(r'<devel.*>',
                                     r'<devel package="{}"/>'.format(pkgname),
                                     newmeta)
                    newmeta = re.sub(r'<bcntsynctag>.*</bcntsynctag>',
                                     r'',
                                     newmeta)
                    newmeta = re.sub(r'</package>',
                                     r'<bcntsynctag>{}</bcntsynctag></package>'.format(pkgname),
                                     newmeta)
                    source_file_save(self.api.apiurl, project, package, '_meta', newmeta)
                    link = "<link package=\"{}\" cicount=\"copy\" />".format(pkgname)
                    source_file_save(self.api.apiurl, project, package, '_link', link)
        return True

    def update_version_attribute(self, project, version):
        version_attr = attribute_value_load(self.api.apiurl, project, 'ProductVersion')
        if version_attr != version:
            attribute_value_save(self.api.apiurl, project, 'ProductVersion', version)

    def update_factory_version(self):
        """Update project (Factory, 13.2, ...) version if is necessary."""

        # XXX TODO - This method have `factory` in the name.  Can be
        # missleading.

        project = self.api.project
        curr_version = date.today().strftime('%Y%m%d')
        update_version_attr = False
        url = self.api.makeurl(['source', project], {'view': 'productlist'})

        products = ET.parse(http_GET(url)).getroot()
        for product in products.findall('product'):
            product_name = product.get('name') + '.product'
            product_pkg = product.get('originpackage')
            product_spec = source_file_load(self.api.apiurl, project, product_pkg, product_name)
            new_product = re.sub(r'<version>\d{8}</version>', '<version>%s</version>' % curr_version, product_spec)

            if product_spec != new_product:
                update_version_attr = True
                url = self.api.makeurl(['source', project, product_pkg,  product_name])
                http_PUT(url + '?comment=Update+version', data=new_product)

        if update_version_attr:
            self.update_version_attribute(project, curr_version)

        ports_prjs = ['PowerPC', 'ARM', 'zSystems' ]

        for ports in ports_prjs:
            project = self.api.project + ':' + ports
            if self.api.item_exists(project) and update_version_attr:
                self.update_version_attribute(project, curr_version)

    def sync_buildfailures(self):
        """
        Trigger rebuild of packages that failed build in either
        openSUSE:Factory or openSUSE:Factory:Rebuild, but not the
        other Helps over the fact that openSUSE:Factory uses
        rebuild=local, thus sometimes 'hiding' build failures.
        """

        for arch in ["x86_64", "i586"]:
            fact_result = self.api.get_prj_results(self.api.project, arch)
            fact_result = self.api.check_pkgs(fact_result)
            rebuild_result = self.api.get_prj_results(self.api.crebuild, arch)
            rebuild_result = self.api.check_pkgs(rebuild_result)
            result = set(rebuild_result) ^ set(fact_result)

            print(sorted(result))

            for package in result:
                self.api.rebuild_pkg(package, self.api.project, arch, None)
                self.api.rebuild_pkg(package, self.api.crebuild, arch, None)

1	import re	1✔
2
3	try:	1✔
4	from urllib.error import HTTPError	1✔
5	except ImportError:	×
6	#python 2.x
7	from urllib2 import HTTPError	×
8
9	import warnings	1✔
10	from xml.etree import cElementTree as ET	1✔
11
12	from osc.core import change_request_state, show_package_meta, wipebinaries	1✔
13	from osc.core import http_GET, http_PUT, http_DELETE, http_POST	1✔
14	from osc.core import delete_package, search, set_devel_project	1✔
15	from osclib.config_command import ConfigCommand	1✔
16	from osclib.core import attribute_value_save	1✔
17	from osclib.core import attribute_value_load	1✔
18	from osclib.core import source_file_load	1✔
19	from osclib.core import source_file_save	1✔
20	from datetime import date	1✔
21
22
23	class AcceptCommand(object):	1✔
24	def __init__(self, api):	1✔
25	self.api = api	1✔
26
27	def find_new_requests(self, project):	1✔
28	query = "match=state/@name='new'+and+action/target/@project='{}'".format(project)	×
29	url = self.api.makeurl(['search', 'request'], query)	×
30
31	f = http_GET(url)	×
32	root = ET.parse(f).getroot()	×
33
34	rqs = []	×
35	for rq in root.findall('request'):	×
36	pkgs = []	×
37	act_type = None	×
38	actions = rq.findall('action')	×
39	for action in actions:	×
40	act_type = action.get('type')	×
41	targets = action.findall('target')	×
42	for t in targets:	×
43	pkgs.append(str(t.get('package')))	×
44
45	rqs.append({'id': int(rq.get('id')), 'packages': pkgs, 'type': act_type})	×
46	return rqs	×
47
48	def virtual_accept_request_has_no_binary(self, project, package):	1✔
49	filelist = self.api.get_filelist_for_package(pkgname=package, project=self.api.project, expand='1', extension='spec')	×
50	pkgs = self.api.extract_specfile_short(filelist)	×
51
52	for pkg in pkgs:	×
53	query = {'view': 'binarylist', 'package': pkg, 'multibuild': '1'}	×
54	pkg_binarylist = ET.parse(http_GET(self.api.makeurl(['build', project, '_result'], query=query))).getroot()	×
55	for binary in pkg_binarylist.findall('./result/binarylist/binary'):	×
56	return False	×
57
58	return True	×
59
60	def find_virtually_accepted_requests(self, project):	1✔
61	query = "match=state/@name='review'+and+(action/target/@project='{}'+and+action/@type='delete')+and+(review/@state='new'+and+review/@by_group='{}')".format(project, self.api.cdelreq_review)	×
62	url = self.api.makeurl(['search', 'request'], query)	×
63
64	f = http_GET(url)	×
65	root = ET.parse(f).getroot()	×
66
67	rqs = []	×
68	for rq in root.findall('request'):	×
69	pkgs = []	×
70	actions = rq.findall('action')	×
71	for action in actions:	×
72	targets = action.findall('target')	×
73	for t in targets:	×
74	pkgs.append(str(t.get('package')))	×
75
76	rqs.append({'id': int(rq.get('id')), 'packages': pkgs})	×
77	return rqs	×
78
79	def reset_rebuild_data(self, project):	1✔
80	data = self.api.pseudometa_file_load('support_pkg_rebuild')	×
81	if data is None:	×
82	return	×
83
84	root = ET.fromstring(data)	×
85	for stg in root.findall('staging'):	×
86	if stg.get('name') == project:	×
87	stg.find('rebuild').text = 'unknown'	×
88	stg.find('supportpkg').text = ''	×
89
90	# reset accpted staging project rebuild state to unknown and clean up
91	# supportpkg list
92	content = ET.tostring(root)	×
93	if content != data:	×
94	self.api.pseudometa_file_save('support_pkg_rebuild', content, 'accept command update')	×
95
96	def virtually_accept_delete(self, request_id, package):	1✔
97	self.api.add_review(request_id, by_group=self.api.cdelreq_review, msg='Request accepted. Cleanup in progress - DO NOT REVOKE!')	×
98
99	filelist = self.api.get_filelist_for_package(pkgname=package, project=self.api.project, expand='1', extension='spec')	×
100	pkgs = self.api.extract_specfile_short(filelist)	×
101
102	# Disable build and wipes the binary to the package and the sub-package
103	for pkg in pkgs:	×
104	meta = show_package_meta(self.api.apiurl, self.api.project, pkg)	×
105	meta = ''.join(meta)	×
106	# Update package meta to disable build
107	self.api.create_package_container(self.api.project, pkg, meta=meta, disable_build=True)	×
108	wipebinaries(self.api.apiurl, self.api.project, package=pkg, repo=self.api.cmain_repo)	×
109
110	# Remove package from Rings
111	if self.api.ring_packages.get(pkg):	×
112	delete_package(self.api.apiurl, self.api.ring_packages.get(pkg), pkg, force=True, msg="Cleanup package in Rings")	×
113
114	def perform(self, project, force=False):	1✔
115	"""Accept the staging project for review and submit to Factory /
116	openSUSE 13.2 ...
117
118	Then disable the build to disabled
119	:param project: staging project we are working with
120
121	"""
122
123	status = self.api.check_project_status(project)	1✔
124
125	if not status:	1✔
126	print('The project "{}" is not yet acceptable.'.format(project))	×
127	if not force:	×
128	return False	×
129
130	meta = self.api.get_prj_pseudometa(project)	1✔
131	packages = []	1✔
132	for req in meta['requests']:	1✔
133	self.api.rm_from_prj(project, request_id=req['id'], msg='ready to accept')	1✔
134	packages.append(req['package'])	1✔
135	msg = 'Accepting staging review for {}'.format(req['package'])	1✔
136
137	oldspecs = self.api.get_filelist_for_package(pkgname=req['package'],	1✔
138	project=self.api.project,
139	extension='spec')
140	if 'type' in req and req['type'] == 'delete' and self.api.cdelreq_review:	1✔
141	msg += ' and started handling of virtual accept process'	×
142	print(msg)	×
143	# Virtually accept the delete request
144	self.virtually_accept_delete(req['id'], req['package'])	×
145	else:
146	print(msg)	1✔
147	change_request_state(self.api.apiurl,	1✔
148	str(req['id']),
149	'accepted',
150	message='Accept to %s' % self.api.project,
151	force=force)
152	self.create_new_links(self.api.project, req['package'], oldspecs)	1✔
153
154	self.api.accept_status_comment(project, packages)	1✔
155	self.api.staging_deactivate(project)	1✔
156	ConfigCommand(self.api).perform([project], 'todo')	1✔
157
158	return True	1✔
159
160	def cleanup(self, project):	1✔
161	if not self.api.item_exists(project):	×
162	return False	×
163
164	pkglist = self.api.list_packages(project)	×
165	clean_list = set(pkglist) - set(self.api.cnocleanup_packages)	×
166
167	for package in clean_list:	×
168	print("[cleanup] deleted %s/%s" % (project, package))	×
169	delete_package(self.api.apiurl, project, package, force=True, msg="autocleanup")	×
170
171	# wipe Test-DVD binaries and breaks kiwi build
172	if project.startswith('openSUSE:'):	×
173	for package in pkglist:	×
174	if package.startswith('Test-DVD-'):	×
175	# intend to break the kiwi file
176	arch = package.split('-')[-1]	×
177	fakepkgname = 'I-am-breaks-kiwi-build'	×
178	oldkiwifile = source_file_load(self.api.apiurl, project, package, 'PRODUCT-'+arch+'.kiwi')	×
179	if oldkiwifile is not None:	×
180	newkiwifile = re.sub(r'<repopackage name="openSUSE-release"/>', '<repopackage name="%s"/>' % fakepkgname, oldkiwifile)	×
181	source_file_save(self.api.apiurl, project, package, 'PRODUCT-' + arch + '.kiwi', newkiwifile)	×
182
183	# do wipe binary now
184	query = { 'cmd': 'wipe' }	×
185	query['package'] = package	×
186	query['repository'] = 'images'	×
187
188	url = self.api.makeurl(['build', project], query)	×
189	try:	×
190	http_POST(url)	×
191	except HTTPError as err:	×
192	# failed to wipe isos but we can just continue
193	pass	×
194
195	return True	×
196
197	def accept_other_new(self):	1✔
198	changed = False	×
199
200	if self.api.cdelreq_review:	×
201	rqlist = self.find_virtually_accepted_requests(self.api.project)	×
202	for req in rqlist:	×
203	if self.virtual_accept_request_has_no_binary(self.api.project, req['packages'][0]):	×
204	# Accepting delreq-review review
205	self.api.do_change_review_state(req['id'], 'accepted',	×
206	by_group=self.api.cdelreq_review,
207	message='Virtually accepted delete {}'.format(req['packages'][0]))
208
209	rqlist = self.find_new_requests(self.api.project)	×
210	if self.api.cnonfree:	×
211	rqlist += self.find_new_requests(self.api.cnonfree)	×
212
213	for req in rqlist:	×
214	oldspecs = self.api.get_filelist_for_package(pkgname=req['packages'][0], project=self.api.project, extension='spec')	×
215	print('Accepting request %d: %s' % (req['id'], ','.join(req['packages'])))	×
216	if req['type'] == 'delete':	×
217	# Remove devel project/package tag before accepting the request
218	self.remove_obsoleted_develtag(self.api.project, req['packages'][0])	×
219	change_request_state(self.api.apiurl, str(req['id']), 'accepted', message='Accept to %s' % self.api.project)	×
220	# Check if all .spec files of the package we just accepted has a package container to build
221	self.create_new_links(self.api.project, req['packages'][0], oldspecs)	×
222	changed = True	×
223
224	return changed	×
225
226	def remove_obsoleted_develtag(self, project, package):	1✔
227	xpath = {	×
228	'package': "@project='%s' and devel/@project=@project and devel/@package='%s'" % (project, package),
229	}
230	collection = search(self.api.apiurl, **xpath)['package']	×
231	for pkg in collection.findall('package'):	×
232	set_devel_project(self.api.apiurl, project, pkg.attrib['name'], devprj=None)	×
233
234	def create_new_links(self, project, pkgname, oldspeclist):	1✔
235	filelist = self.api.get_filelist_for_package(pkgname=pkgname, project=project, extension='spec')	1✔
236	removedspecs = set(oldspeclist) - set(filelist)	1✔
237	for spec in removedspecs:	1✔
238	# Deleting all the packages that no longer have a .spec file
239	url = self.api.makeurl(['source', project, spec[:-5]])	×
240	print("Deleting package %s from project %s" % (spec[:-5], project))	×
241	try:	×
242	http_DELETE(url)	×
243	except HTTPError as err:	×
244	if err.code == 404:	×
245	# the package link was not yet created, which was likely a mistake from earlier
246	pass	×
247	else:
248	# If the package was there bug could not be delete, raise the error
249	raise	×
250
251	# Remove package from Rings in case 2nd specfile was removed
252	if self.api.ring_packages.get(spec[:-5]):	×
253	delete_package(self.api.apiurl, self.api.ring_packages.get(spec[:-5]), spec[:-5], force=True, msg="Cleanup package in Rings")	×
254
255	if len(filelist) > 1:	1✔
256	# There is more than one .spec file in the package; link package containers as needed
257	origmeta = source_file_load(self.api.apiurl, project, pkgname, '_meta')	×
258	for specfile in filelist:	×
259	package = specfile[:-5] # stripping .spec off the filename gives the packagename	×
260	if package == pkgname:	×
261	# This is the original package and does not need to be linked to itself
262	continue	×
263	# Check if the target package already exists, if it does not, we get a HTTP error 404 to catch
264	if not self.api.item_exists(project, package):	×
265	print("Creating new package %s linked to %s" % (package, pkgname))	×
266	# new package does not exist. Let's link it with new metadata
267	newmeta = re.sub(r'(<package.*name=.){}'.format(pkgname),	×
268	r'\1{}'.format(package),
269	origmeta)
270	newmeta = re.sub(r'<devel.*>',	×
271	r'<devel package="{}"/>'.format(pkgname),
272	newmeta)
273	newmeta = re.sub(r'<bcntsynctag>.*</bcntsynctag>',	×
274	r'',
275	newmeta)
276	newmeta = re.sub(r'</package>',	×
277	r'<bcntsynctag>{}</bcntsynctag></package>'.format(pkgname),
278	newmeta)
279	source_file_save(self.api.apiurl, project, package, '_meta', newmeta)	×
280	link = "<link package=\"{}\" cicount=\"copy\" />".format(pkgname)	×
281	source_file_save(self.api.apiurl, project, package, '_link', link)	×
282	return True	1✔
283
284	def update_version_attribute(self, project, version):	1✔
285	version_attr = attribute_value_load(self.api.apiurl, project, 'ProductVersion')	×
286	if version_attr != version:	×
287	attribute_value_save(self.api.apiurl, project, 'ProductVersion', version)	×
288
289	def update_factory_version(self):	1✔
290	"""Update project (Factory, 13.2, ...) version if is necessary."""
291
292	# XXX TODO - This method have `factory` in the name. Can be
293	# missleading.
294
295	project = self.api.project	×
296	curr_version = date.today().strftime('%Y%m%d')	×
297	update_version_attr = False	×
298	url = self.api.makeurl(['source', project], {'view': 'productlist'})	×
299
300	products = ET.parse(http_GET(url)).getroot()	×
301	for product in products.findall('product'):	×
302	product_name = product.get('name') + '.product'	×
303	product_pkg = product.get('originpackage')	×
304	product_spec = source_file_load(self.api.apiurl, project, product_pkg, product_name)	×
305	new_product = re.sub(r'<version>\d{8}</version>', '<version>%s</version>' % curr_version, product_spec)	×
306
307	if product_spec != new_product:	×
308	update_version_attr = True	×
309	url = self.api.makeurl(['source', project, product_pkg, product_name])	×
310	http_PUT(url + '?comment=Update+version', data=new_product)	×
311
312	if update_version_attr:	×
313	self.update_version_attribute(project, curr_version)	×
314
315	ports_prjs = ['PowerPC', 'ARM', 'zSystems' ]	×
316
317	for ports in ports_prjs:	×
318	project = self.api.project + ':' + ports	×
319	if self.api.item_exists(project) and update_version_attr:	×
320	self.update_version_attribute(project, curr_version)	×
321
322	def sync_buildfailures(self):	1✔
323	"""
324	Trigger rebuild of packages that failed build in either
325	openSUSE:Factory or openSUSE:Factory:Rebuild, but not the
326	other Helps over the fact that openSUSE:Factory uses
327	rebuild=local, thus sometimes 'hiding' build failures.
328	"""
329
330	for arch in ["x86_64", "i586"]:	×
331	fact_result = self.api.get_prj_results(self.api.project, arch)	×
332	fact_result = self.api.check_pkgs(fact_result)	×
333	rebuild_result = self.api.get_prj_results(self.api.crebuild, arch)	×
334	rebuild_result = self.api.check_pkgs(rebuild_result)	×
335	result = set(rebuild_result) ^ set(fact_result)	×
336
337	print(sorted(result))	×
338
339	for package in result:	×
340	self.api.rebuild_pkg(package, self.api.project, arch, None)	×
341	self.api.rebuild_pkg(package, self.api.crebuild, arch, None)	×

openSUSE / openSUSE-release-tools / 5081

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous