def package_orphan(package, collection):
''' Gives the possibility to orphan or take a package. '''
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(SESSION, packagename)
package = pkgdblib.search_package(SESSION, packagename, limit=1)[0]
except NoResultFound:
SESSION.rollback()
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
except IndexError:
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
for acl in package_acl:
if acl.collection.branchname == collection:
try:
pkgdblib.update_pkg_poc(session=SESSION,
pkg_name=package.name,
clt_name=acl.collection.branchname,
pkg_poc='orphan',
user=flask.g.fas_user)
flask.flash(
'You are no longer point of contact on branch: %s' %
collection)
except pkgdblib.PkgdbException, err:
flask.flash(err.message, 'error')
break
def package_retire(package, collection):
''' Gives the possibility to orphan or take a package. '''
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(SESSION, packagename)
package = pkgdblib.search_package(SESSION, packagename, limit=1)[0]
except (NoResultFound, IndexError):
SESSION.rollback()
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
for acl in package_acl:
if acl.collection.branchname == collection:
if acl.point_of_contact == 'orphan':
try:
pkgdblib.update_pkg_status(
session=SESSION,
pkg_name=package.name,
pkg_branch=acl.collection.branchname,
status='Retired',
user=flask.g.fas_user
)
flask.flash(
'This package has been retired on branch: %s'
% collection)
except pkgdblib.PkgdbException, err:
flask.flash(err.message, 'error')
SESSION.rollback()
break
else:
flask.flash(
'This package has not been orphaned on '
'branch: %s' % collection)
def comaintain_package(package):
if not 'packager' in flask.g.fas_user.groups:
flask.flash(
'You must be a packager to apply to be a comaintainer',
'errors')
return flask.redirect(flask.url_for(
'.package_info', package=package))
pkg = pkgdblib.search_package(SESSION, pkg_name=package, limit=1)[0]
pkg_acls = ['commit', 'watchcommits', 'watchbugzilla']
pkg_branchs = [pkglist.collection.branchname for pkglist in pkg.listings]
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
acl_status = 'Awaiting Review'
if acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
clt_name=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
return flask.redirect(
flask.url_for('.package_info',
package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
def packager_info(packager):
''' Display the information about the specified packager. '''
packages = []
packages_co = []
try:
packages_co = pkgdblib.get_package_maintained(
SESSION,
packager=packager
)
except NoResultFound:
SESSION.rollback()
# clean co-maintained packages and split out PoC packages
cnt = 0
while cnt < len(packages_co):
maint = []
for acls in packages_co[cnt].listings:
maint.append(acls.point_of_contact)
if packager in maint:
packages.append(packages_co[cnt])
del(packages_co[cnt])
cnt -= 1
cnt += 1
if not packages and not packages_co:
flask.flash('No packager of this name found.', 'errors')
return flask.render_template('msg.html')
return flask.render_template(
'packager.html',
packager=packager,
packages=packages,
packages_co=packages_co,
)
def package_retire(package, collection):
''' Gives the possibility to orphan or take a package. '''
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(SESSION, packagename)
package = pkgdblib.search_package(SESSION, packagename, limit=1)[0]
except NoResultFound:
SESSION.rollback()
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
except IndexError:
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
for acl in package_acl:
if acl.collection.branchname == collection:
if acl.point_of_contact == 'orphan':
try:
pkgdblib.update_pkg_status(
session=SESSION,
pkg_name=package.name,
clt_name=acl.collection.branchname,
status='Deprecated',
user=flask.g.fas_user)
flask.flash('This package has been retired on branch: %s' %
collection)
except pkgdblib.PkgdbException, err:
flask.flash(err.message, 'error')
break
else:
flask.flash('This package has not been orphaned on '
'branch: %s' % collection)
def comaintain_package(package):
if not 'packager' in flask.g.fas_user.groups:
flask.flash('You must be a packager to apply to be a comaintainer',
'errors')
return flask.redirect(flask.url_for('.package_info', package=package))
pkg = pkgdblib.search_package(SESSION, pkg_name=package, limit=1)[0]
pkg_acls = ['commit', 'watchcommits', 'watchbugzilla']
pkg_branchs = [pkglist.collection.branchname for pkglist in pkg.listings]
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
acl_status = 'Awaiting Review'
if acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
clt_name=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
return flask.redirect(flask.url_for('.package_info', package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
def package_orphan(package, collection):
''' Gives the possibility to orphan or take a package. '''
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(SESSION, packagename)
package = pkgdblib.search_package(SESSION, packagename, limit=1)[0]
except NoResultFound:
SESSION.rollback()
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
except IndexError:
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
for acl in package_acl:
if acl.collection.branchname == collection:
try:
pkgdblib.update_pkg_poc(
session=SESSION,
pkg_name=package.name,
clt_name=acl.collection.branchname,
pkg_poc='orphan',
user=flask.g.fas_user
)
flask.flash(
'You are no longer point of contact on branch: %s'
% collection)
except pkgdblib.PkgdbException, err:
flask.flash(err.message, 'error')
break
def watch_package(package):
''' Request watch* ACLs on a package.
Anyone can request these ACLs, no need to be a packager.
'''
try:
pkg = pkgdblib.search_package(SESSION, pkg_name=package, limit=1)[0]
except IndexError:
flask.flash('No package found by this name', 'error')
return flask.redirect(
flask.url_for('.package_info', package=package))
pkg_acls = ['watchcommits', 'watchbugzilla']
pkg_branchs = [pkglist.collection.branchname for pkglist in pkg.listings]
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
pkg_branch=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status='Approved',
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
# Let's keep this in although we should never see it
except pkgdblib.PkgdbException, err: # pragma: no cover
SESSION.rollback()
flask.flash(err.message, 'error')
def collection_new():
''' Page to create a new collection. '''
clt_status = pkgdb.lib.get_status(SESSION, 'clt_status')['clt_status']
form = pkgdb.forms.AddCollectionForm(clt_status=clt_status)
if form.validate_on_submit():
clt_name = form.collection_name.data
clt_version = form.collection_version.data
clt_status = form.collection_status.data
clt_branchname = form.collection_branchname.data
clt_disttag = form.collection_distTag.data
clt_gitbranch = form.collection_git_branch_name.data
try:
message = pkgdblib.add_collection(
SESSION,
clt_name=clt_name,
clt_version=clt_version,
clt_status=clt_status,
clt_branchname=clt_branchname,
clt_disttag=clt_disttag,
clt_gitbranch=clt_gitbranch,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash(message)
return flask.redirect(flask.url_for('.list_collections'))
# In theory we should never hit this
except pkgdblib.PkgdbException, err: # pragma: no cover
SESSION.rollback()
flask.flash(err.message, 'errors')
def packager_info(packager):
''' Display the information about the specified packager. '''
packages = []
packages_co = []
try:
packages_co = pkgdblib.get_package_maintained(SESSION,
packager=packager)
except NoResultFound:
SESSION.rollback()
# clean co-maintained packages and split out PoC packages
cnt = 0
while cnt < len(packages_co):
maint = []
for acls in packages_co[cnt].listings:
maint.append(acls.point_of_contact)
if packager in maint:
packages.append(packages_co[cnt])
del (packages_co[cnt])
cnt -= 1
cnt += 1
if not packages and not packages_co:
flask.flash('No packager of this name found.', 'errors')
return flask.render_template('msg.html')
return flask.render_template(
'packager.html',
packager=packager,
packages=packages,
packages_co=packages_co,
)
def package_info(package):
''' Display the information about the specified package. '''
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(SESSION, packagename)
package = pkgdblib.search_package(SESSION, packagename, limit=1)[0]
except NoResultFound:
SESSION.rollback()
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
except IndexError:
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
package_acls = []
branch_admin = []
is_poc = False
for pkg in package_acl:
tmp = {}
tmp['collection'] = '%s %s' % (pkg.collection.name,
pkg.collection.version)
tmp['branchname'] = pkg.collection.branchname
tmp['point_of_contact'] = pkg.point_of_contact
if hasattr(flask.g, 'fas_user') and flask.g.fas_user and \
pkg.point_of_contact == flask.g.fas_user.username:
is_poc = True
acls = {}
for acl in pkg.acls:
tmp2 = {'acl': acl.acl, 'status': acl.status}
if acl.fas_name in acls:
acls[acl.fas_name].append(tmp2)
else:
acls[acl.fas_name] = [tmp2]
## This list is a little hacky, but we would have to save ACLs
## in their own table otherwise.
planned_acls = set(['approveacls', 'commit', 'watchbugzilla',
'watchcommits'])
seen_acls = set([aclobj['acl'] for aclobj in acls[acl.fas_name]])
for aclname in planned_acls - seen_acls:
acls[acl.fas_name].append({'acl': aclname, 'status': ''})
tmp['acls'] = acls
package_acls.append(tmp)
if is_pkg_admin(flask.g.fas_user, package.name,
pkg.collection.branchname):
branch_admin.append(pkg.collection.branchname)
return flask.render_template(
'package.html',
package=package,
package_acl=package_acls,
branch_admin=branch_admin,
is_poc=is_poc,
)
def package_info(package):
''' Display the information about the specified package. '''
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(SESSION, packagename)
package = pkgdblib.search_package(SESSION, packagename, limit=1)[0]
except NoResultFound:
SESSION.rollback()
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
except IndexError:
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
package_acls = []
branch_admin = []
is_poc = False
for pkg in package_acl:
tmp = {}
tmp['collection'] = '%s %s' % (pkg.collection.name,
pkg.collection.version)
tmp['branchname'] = pkg.collection.branchname
tmp['point_of_contact'] = pkg.point_of_contact
if hasattr(flask.g, 'fas_user') and flask.g.fas_user and \
pkg.point_of_contact == flask.g.fas_user.username:
is_poc = True
acls = {}
for acl in pkg.acls:
tmp2 = {'acl': acl.acl, 'status': acl.status}
if acl.fas_name in acls:
acls[acl.fas_name].append(tmp2)
else:
acls[acl.fas_name] = [tmp2]
## This list is a little hacky, but we would have to save ACLs
## in their own table otherwise.
planned_acls = set(
['approveacls', 'commit', 'watchbugzilla', 'watchcommits'])
seen_acls = set([aclobj['acl'] for aclobj in acls[acl.fas_name]])
for aclname in planned_acls - seen_acls:
acls[acl.fas_name].append({'acl': aclname, 'status': ''})
tmp['acls'] = acls
package_acls.append(tmp)
if is_pkg_admin(flask.g.fas_user, package.name,
pkg.collection.branchname):
branch_admin.append(pkg.collection.branchname)
return flask.render_template(
'package.html',
package=package,
package_acl=package_acls,
branch_admin=branch_admin,
is_poc=is_poc,
)
def update_acl(package, user, branch=None):
''' Update the acls for a specific user on a package. '''
pending_acls = pkgdblib.get_acl_user_package(SESSION,
user,
package,
status=None)
if branch is not None:
pending_acls2 = []
for acls in pending_acls:
if acls['collection'] == branch:
pending_acls2.append(acls)
pending_acls = pending_acls2
collections = set([item['collection'] for item in pending_acls])
status = pkgdb.lib.get_status(SESSION, ['pkg_acl', 'pkg_status'])
form = pkgdb.forms.UpdateAclPackageForm(
collections=collections,
pkg_acl_list=status['pkg_acl'],
pkg_status=status['pkg_status'],
)
if form.validate_on_submit():
pkg_branchs = form.pkg_branch.data
pkg_acls = form.pkg_acl.data
acl_status = form.acl_status.data
try:
branch_out = []
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
if collec in branch_out:
continue
if acl_status == 'Awaiting Review' and \
acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
clt_name=collec,
pkg_user=user,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
flask.flash('ACLs updated')
SESSION.commit()
return flask.redirect(
flask.url_for('.package_info', package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'errors')
def update_acl(package, user, branch=None):
''' Update the acls for a specific user on a package. '''
pending_acls = pkgdblib.get_acl_user_package(
SESSION, user, package, status=None)
if branch is not None:
pending_acls2 = []
for acls in pending_acls:
if acls['collection'] == branch:
pending_acls2.append(acls)
pending_acls = pending_acls2
collections = set([item['collection'] for item in pending_acls])
status = pkgdb.lib.get_status(SESSION, ['pkg_acl', 'pkg_status'])
form = pkgdb.forms.UpdateAclPackageForm(
collections=collections,
pkg_acl_list=status['pkg_acl'],
pkg_status=status['pkg_status'],
)
if form.validate_on_submit():
pkg_branchs = form.pkg_branch.data
pkg_acls = form.pkg_acl.data
acl_status = form.acl_status.data
try:
branch_out = []
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
if collec in branch_out:
continue
if acl_status == 'Awaiting Review' and \
acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
clt_name=collec,
pkg_user=user,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
flask.flash('ACLs updated')
SESSION.commit()
return flask.redirect(
flask.url_for('.package_info',
package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'errors')
def collection_edit(collection):
''' Allows to edit the information about the specified collection. '''
collections = []
try:
collection = pkgdblib.search_collection(SESSION, collection)[0]
except NoResultFound:
SESSION.rollback()
except IndexError:
flask.flash('No collection of this name found.', 'errors')
return flask.render_template('msg.html')
clt_status = pkgdb.lib.get_status(SESSION, 'clt_status')['clt_status']
form = pkgdb.forms.AddCollectionForm(
clt_status=clt_status
)
if form.validate_on_submit():
clt_name = form.collection_name.data
clt_version = form.collection_version.data
clt_status = form.collection_status.data
clt_publishurl = form.collection_publishURLTemplate.data
clt_pendingurl = form.collection_pendingURLTemplate.data
clt_summary = form.collection_summary.data
clt_description = form.collection_description.data
clt_branchname = form.collection_branchname.data
clt_disttag = form.collection_distTag.data
clt_gitbranch = form.collection_git_branch_name.data
try:
pkgdblib.edit_collection(
SESSION,
collection=collection,
clt_name=clt_name,
clt_version=clt_version,
clt_status=clt_status,
clt_publishurl=clt_publishurl,
clt_pendingurl=clt_pendingurl,
clt_summary=clt_summary,
clt_description=clt_description,
clt_branchname=clt_branchname,
clt_disttag=clt_disttag,
clt_gitbranch=clt_gitbranch,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('Collection "%s" edited' % clt_name)
return flask.redirect(flask.url_for(
'.collection_info', collection=collection.branchname))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'errors')
def package_take(package, collection):
''' Make someone Point of contact of an orphaned package. '''
try:
pkgdblib.unorphan_package(session=SESSION,
pkg_name=package,
clt_name=collection,
pkg_user=flask.g.fas_user.username,
user=flask.g.fas_user)
SESSION.commit()
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
def collection_edit(collection):
''' Allows to edit the information about the specified collection. '''
collections = []
try:
collection = pkgdblib.search_collection(SESSION, collection)[0]
except NoResultFound:
SESSION.rollback()
except IndexError:
flask.flash('No collection of this name found.', 'errors')
return flask.render_template('msg.html')
clt_status = pkgdb.lib.get_status(SESSION, 'clt_status')['clt_status']
form = pkgdb.forms.AddCollectionForm(clt_status=clt_status)
if form.validate_on_submit():
clt_name = form.collection_name.data
clt_version = form.collection_version.data
clt_status = form.collection_status.data
clt_publishurl = form.collection_publishURLTemplate.data
clt_pendingurl = form.collection_pendingURLTemplate.data
clt_summary = form.collection_summary.data
clt_description = form.collection_description.data
clt_branchname = form.collection_branchname.data
clt_disttag = form.collection_distTag.data
clt_gitbranch = form.collection_git_branch_name.data
try:
pkgdblib.edit_collection(
SESSION,
collection=collection,
clt_name=clt_name,
clt_version=clt_version,
clt_status=clt_status,
clt_publishurl=clt_publishurl,
clt_pendingurl=clt_pendingurl,
clt_summary=clt_summary,
clt_description=clt_description,
clt_branchname=clt_branchname,
clt_disttag=clt_disttag,
clt_gitbranch=clt_gitbranch,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('Collection "%s" edited' % clt_name)
return flask.redirect(
flask.url_for('.collection_info',
collection=collection.branchname))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'errors')
def package_take(package, collection):
''' Make someone Point of contact of an orphaned package. '''
try:
pkgdblib.unorphan_package(
session=SESSION,
pkg_name=package,
clt_name=collection,
pkg_user=flask.g.fas_user.username,
user=flask.g.fas_user
)
SESSION.commit()
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
def collection_info(collection):
''' Display the information about the specified collection. '''
collections = []
try:
collection = pkgdblib.search_collection(SESSION, collection)[0]
except NoResultFound:
SESSION.rollback()
except IndexError:
flask.flash('No collection of this name found.', 'errors')
return flask.render_template('msg.html')
return flask.render_template(
'collection.html',
collection=collection,
)
def collection_info(collection):
''' Display the information about the specified collection. '''
collections = []
try:
collection = pkgdblib.search_collection(SESSION, collection)[0]
except NoResultFound:
SESSION.rollback()
except IndexError:
flask.flash('No collection of this name found.', 'errors')
return flask.render_template('msg.html')
return flask.render_template(
'collection.html',
collection=collection,
)
def package_new():
''' Page to create a new package. '''
collections = pkgdb.lib.search_collection(
SESSION, '*', 'Under Development')
collections.extend(pkgdb.lib.search_collection(SESSION, '*', 'Active'))
pkg_status = pkgdb.lib.get_status(SESSION, 'pkg_status')['pkg_status']
form = pkgdb.forms.AddPackageForm(
collections=collections,
pkg_status_list=pkg_status,
)
if form.validate_on_submit():
pkg_name = form.pkg_name.data
pkg_summary = form.pkg_summary.data
pkg_description = form.pkg_description.data
pkg_review_url = form.pkg_reviewURL.data
pkg_status = form.pkg_status.data
pkg_shouldopen = form.pkg_shouldopen.data
pkg_critpath = form.pkg_critpath.data
pkg_collection = form.pkg_collection.data
pkg_poc = form.pkg_poc.data
pkg_upstream_url = form.pkg_upstreamURL.data
try:
message = pkgdblib.add_package(
SESSION,
pkg_name=pkg_name,
pkg_summary=pkg_summary,
pkg_description=pkg_description,
pkg_reviewURL=pkg_review_url,
pkg_status=pkg_status,
pkg_shouldopen=pkg_shouldopen,
pkg_critpath=pkg_critpath,
pkg_collection=pkg_collection,
pkg_poc=pkg_poc,
pkg_upstreamURL=pkg_upstream_url,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash(message)
return flask.redirect(flask.url_for('.list_packages'))
# Keep it in, but normally we shouldn't hit this
except pkgdblib.PkgdbException, err: # pragma: no cover
SESSION.rollback()
flask.flash(err.message, 'error')
def request_acl(package):
''' Request acls for a specific package. '''
collections = pkgdb.lib.search_collection(
SESSION, '*', 'Under Development')
collections.extend(pkgdb.lib.search_collection(SESSION, '*', 'Active'))
pkg_acl = pkgdb.lib.get_status(SESSION, 'pkg_acl')['pkg_acl']
form = pkgdb.forms.RequestAclPackageForm(
collections=collections,
pkg_acl_list=pkg_acl
)
if form.validate_on_submit():
pkg_branchs = form.pkg_branch.data
pkg_acls = form.pkg_acl.data
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
acl_status = 'Awaiting Review'
if acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
elif 'packager' not in flask.g.fas_user.groups:
flask.flash(
'You must be a packager to apply to the'
' ACL: %s on %s' % (acl, collec), 'errors')
continue
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
clt_name=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
return flask.redirect(
flask.url_for('.package_info',
package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
def comaintain_package(package):
''' Asks for ACLs to co-maintain a package.
You need to be a packager to request co-maintainership.
'''
# This is really wearing belt and suspenders, the decorator above
# should take care of this
if not 'packager' in flask.g.fas_user.groups: # pragma: no cover
flask.flash(
'You must be a packager to apply to be a comaintainer',
'errors')
return flask.redirect(flask.url_for(
'.package_info', package=package))
try:
pkg = pkgdblib.search_package(SESSION, pkg_name=package, limit=1)[0]
except IndexError:
flask.flash('No package found by this name', 'error')
return flask.redirect(
flask.url_for('.package_info', package=package))
pkg_acls = ['commit', 'watchcommits', 'watchbugzilla']
pkg_branchs = [pkglist.collection.branchname for pkglist in pkg.listings]
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
acl_status = 'Awaiting Review'
if acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
pkg_branch=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
# Let's keep this in although we should never see it
except pkgdblib.PkgdbException, err: # pragma: no cover
SESSION.rollback()
flask.flash(err.message, 'error')
def collection_edit(collection):
''' Allows to edit the information about the specified collection. '''
try:
collection = pkgdblib.search_collection(SESSION, collection)[0]
except IndexError:
flask.flash('No collection of this name found.', 'errors')
return flask.render_template('msg.html')
clt_status = pkgdb.lib.get_status(SESSION, 'clt_status')['clt_status']
form = pkgdb.forms.AddCollectionForm(
clt_status=clt_status
)
if form.validate_on_submit():
clt_name = form.collection_name.data
clt_version = form.collection_version.data
clt_status = form.collection_status.data
clt_branchname = form.collection_branchname.data
clt_disttag = form.collection_distTag.data
clt_gitbranch = form.collection_git_branch_name.data
try:
pkgdblib.edit_collection(
SESSION,
collection=collection,
clt_name=clt_name,
clt_version=clt_version,
clt_status=clt_status,
clt_branchname=clt_branchname,
clt_disttag=clt_disttag,
clt_gitbranch=clt_gitbranch,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('Collection "%s" edited' % clt_branchname)
return flask.redirect(flask.url_for(
'.collection_info', collection=collection.branchname))
# In theory we should never hit this
except pkgdblib.PkgdbException, err: # pragma: no cover
SESSION.rollback()
flask.flash(err.message, 'errors')
def request_acl(package):
''' Request acls for a specific package. '''
collections = pkgdb.lib.search_collection(SESSION, '*',
'Under Development')
collections.extend(pkgdb.lib.search_collection(SESSION, '*', 'Active'))
pkg_acl = pkgdb.lib.get_status(SESSION, 'pkg_acl')['pkg_acl']
form = pkgdb.forms.RequestAclPackageForm(collections=collections,
pkg_acl_list=pkg_acl)
if form.validate_on_submit():
pkg_branchs = form.pkg_branch.data
pkg_acls = form.pkg_acl.data
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
acl_status = 'Awaiting Review'
if acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
elif 'packager' not in flask.g.fas_user.groups:
flask.flash(
'You must be a packager to apply to the'
' ACL: %s on %s' % (acl, collec), 'errors')
continue
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
clt_name=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
return flask.redirect(
flask.url_for('.package_info', package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
def package_new():
''' Page to create a new package. '''
collections = pkgdb.lib.search_collection(SESSION, '*',
'Under Development')
collections.extend(pkgdb.lib.search_collection(SESSION, '*', 'Active'))
pkg_status = pkgdb.lib.get_status(SESSION, 'pkg_status')['pkg_status']
form = pkgdb.forms.AddPackageForm(
collections=collections,
pkg_status_list=pkg_status,
)
if form.validate_on_submit():
pkg_name = form.pkg_name.data
pkg_summary = form.pkg_summary.data
pkg_reviewURL = form.pkg_reviewURL.data
pkg_status = form.pkg_status.data
pkg_shouldopen = form.pkg_shouldopen.data
pkg_collection = form.pkg_collection.data
pkg_poc = form.pkg_poc.data
pkg_upstreamURL = form.pkg_upstreamURL.data
try:
message = pkgdblib.add_package(
SESSION,
pkg_name=pkg_name,
pkg_summary=pkg_summary,
pkg_reviewURL=pkg_reviewURL,
pkg_status=pkg_status,
pkg_shouldopen=pkg_shouldopen,
pkg_collection=pkg_collection,
pkg_poc=pkg_poc,
pkg_upstreamURL=pkg_upstreamURL,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash(message)
return flask.redirect(flask.url_for('.list_packages'))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
def watch_package(package):
pkg = pkgdblib.search_package(SESSION, pkg_name=package)[0]
pkg_acls = ['watchcommits', 'watchbugzilla']
pkg_branchs = [pkglist.collection.branchname for pkglist in pkg.listings]
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
clt_name=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status='Approved',
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
return flask.redirect(flask.url_for('.package_info', package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
def collection_new():
''' Page to create a new collection. '''
clt_status = pkgdb.lib.get_status(SESSION, 'clt_status')['clt_status']
form = pkgdb.forms.AddCollectionForm(clt_status=clt_status)
if form.validate_on_submit():
clt_name = form.collection_name.data
clt_version = form.collection_version.data
clt_status = form.collection_status.data
clt_publishurl = form.collection_publishURLTemplate.data
clt_pendingurl = form.collection_pendingURLTemplate.data
clt_summary = form.collection_summary.data
clt_description = form.collection_description.data
clt_branchname = form.collection_branchname.data
clt_disttag = form.collection_distTag.data
clt_gitbranch = form.collection_git_branch_name.data
try:
message = pkgdblib.add_collection(
SESSION,
clt_name=clt_name,
clt_version=clt_version,
clt_status=clt_status,
clt_publishurl=clt_publishurl,
clt_pendingurl=clt_pendingurl,
clt_summary=clt_summary,
clt_description=clt_description,
clt_branchname=clt_branchname,
clt_disttag=clt_disttag,
clt_gitbranch=clt_gitbranch,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash(message)
return flask.redirect(flask.url_for('.list_collections'))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'errors')
def collection_new():
''' Page to create a new collection. '''
clt_status = pkgdb.lib.get_status(SESSION, 'clt_status')['clt_status']
form = pkgdb.forms.AddCollectionForm(clt_status=clt_status)
if form.validate_on_submit():
clt_name = form.collection_name.data
clt_version = form.collection_version.data
clt_status = form.collection_status.data
clt_publishurl = form.collection_publishURLTemplate.data
clt_pendingurl = form.collection_pendingURLTemplate.data
clt_summary = form.collection_summary.data
clt_description = form.collection_description.data
clt_branchname = form.collection_branchname.data
clt_disttag = form.collection_distTag.data
clt_gitbranch = form.collection_git_branch_name.data
try:
message = pkgdblib.add_collection(
SESSION,
clt_name=clt_name,
clt_version=clt_version,
clt_status=clt_status,
clt_publishurl=clt_publishurl,
clt_pendingurl=clt_pendingurl,
clt_summary=clt_summary,
clt_description=clt_description,
clt_branchname=clt_branchname,
clt_disttag=clt_disttag,
clt_gitbranch=clt_gitbranch,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash(message)
return flask.redirect(flask.url_for('.list_collections'))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'errors')
def watch_package(package):
pkg = pkgdblib.search_package(SESSION, pkg_name=package)[0]
pkg_acls = ['watchcommits', 'watchbugzilla']
pkg_branchs = [pkglist.collection.branchname for pkglist in pkg.listings]
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
clt_name=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status='Approved',
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
return flask.redirect(
flask.url_for('.package_info',
package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
def api_acl_update():
'''
Update package ACL
------------------
Update the ACL for a given package.
::
/api/package/acl/
Accept POST queries only.
:arg pkg_name: String of the package name.
:arg pkg_branch: List of strings with the name of the branches to change,
update.
:arg pkg_acl: List of strings of the ACL to change/update. Possible acl
are: 'commit', 'build', 'watchbugzilla', 'watchcommits',
'approveacls', 'checkout'.
:arg acl_status: String of the type of action required. Possible status
are: 'Approved', 'Awaiting Review', 'Denied', 'Obsolete', 'Removed'.
:kwarg pkg_user: the name of the user that is the target of this ACL
change/update. This will only work if: 1) you are an admin,
2) you are changing one of your package.
Sample response:
::
{
"output": "ok",
"messages": ["user: $USER set acl: $ACL of package: $PACKAGE "
"from: $PREVIOUS_STATUS to $NEW_STATUS on branch: "
"$BRANCH"]
}
{
"output": "notok",
"error": ["You are not allowed to update ACLs of someone else."]
}
'''
httpcode = 200
output = {}
status = pkgdb.lib.get_status(SESSION, ['pkg_acl', 'acl_status'])
form = forms.SetAclPackageForm(
csrf_enabled=False,
pkg_acl=status['pkg_acl'],
acl_status=status['acl_status'],
)
if form.validate_on_submit():
pkg_name = form.pkg_name.data
pkg_branch = form.pkg_branch.data.split(',')
pkg_acl = form.pkg_acl.data
acl_status = form.acl_status.data
pkg_user = form.pkg_user.data
try:
messages = []
for branch in pkg_branch:
message = pkgdblib.set_acl_package(
SESSION,
pkg_name=pkg_name,
pkg_branch=branch,
acl=pkg_acl,
status=acl_status,
pkg_user=pkg_user,
user=flask.g.fas_user,
)
messages.append(message)
SESSION.commit()
output['output'] = 'ok'
output['messages'] = messages
except pkgdblib.PkgdbException, err:
SESSION.rollback()
output['output'] = 'notok'
output['error'] = err.message
httpcode = 500
def package_give(package):
''' Gives the PoC of a package to someone else. '''
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(SESSION, packagename)
package = pkgdblib.search_package(SESSION, packagename, limit=1)[0]
except NoResultFound:
SESSION.rollback()
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
except IndexError:
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
# Restrict the branch to the one current user is PoC of (unless admin
# or group)
collect_name = []
for acl in package_acl:
if acl.point_of_contact != flask.g.fas_user.username and \
not is_pkgdb_admin(flask.g.fas_user) and \
not acl.point_of_contact.startswith('group::'):
pass
else:
if acl.point_of_contact.startswith('group::'):
group = acl.point_of_contact.split('group::')[0]
if group not in flask.g.fas_user.groups:
pass
else:
collect_name.append(acl.collection.branchname)
form = pkgdb.forms.GivePoCForm(collections=collect_name)
acls = ['commit', 'watchbugzilla', 'watchcommits', 'approveacls']
if form.validate_on_submit():
collections = form.pkg_branch.data
pkg_poc = form.pkg_poc.data
if pkg_poc.startswith('group::'):
acls = ['commit', 'watchbugzilla', 'watchcommits']
try:
for pkg_collection in collections:
message = pkgdblib.update_pkg_poc(
SESSION,
pkg_name=packagename,
clt_name=pkg_collection,
pkg_poc=pkg_poc,
user=flask.g.fas_user,
)
flask.flash(message)
for acl in acls:
pkgdblib.set_acl_package(SESSION,
pkg_name=packagename,
clt_name=pkg_collection,
pkg_user=pkg_poc,
acl=acl,
status='Approved',
user=flask.g.fas_user)
SESSION.commit()
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
return flask.redirect(
flask.url_for('.package_info', package=packagename))
pkgdblib.update_pkg_poc(session=SESSION,
pkg_name=package.name,
clt_name=acl.collection.branchname,
pkg_poc='orphan',
user=flask.g.fas_user)
flask.flash(
'You are no longer point of contact on branch: %s' %
collection)
except pkgdblib.PkgdbException, err:
flask.flash(err.message, 'error')
break
try:
SESSION.commit()
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
return flask.redirect(flask.url_for('.package_info', package=package.name))
@UI.route('/package/<package>/<collection>/retire', methods=('GET', 'POST'))
@packager_login_required
def package_retire(package, collection):
''' Gives the possibility to orphan or take a package. '''
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(SESSION, packagename)
package = pkgdblib.search_package(SESSION, packagename, limit=1)[0]
def package_give(package):
''' Gives the PoC of a package to someone else. '''
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(SESSION, packagename)
package = pkgdblib.search_package(SESSION, packagename, limit=1)[0]
except NoResultFound:
SESSION.rollback()
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
except IndexError:
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
# Restrict the branch to the one current user is PoC of (unless admin
# or group)
collect_name = []
for acl in package_acl:
if acl.point_of_contact != flask.g.fas_user.username and \
not is_pkgdb_admin(flask.g.fas_user) and \
not acl.point_of_contact.startswith('group::'):
pass
else:
if acl.point_of_contact.startswith('group::'):
group = acl.point_of_contact.split('group::')[0]
if group not in flask.g.fas_user.groups:
pass
else:
collect_name.append(acl.collection.branchname)
form = pkgdb.forms.GivePoCForm(collections=collect_name)
acls = ['commit', 'watchbugzilla', 'watchcommits', 'approveacls']
if form.validate_on_submit():
collections = form.pkg_branch.data
pkg_poc = form.pkg_poc.data
if pkg_poc.startswith('group::'):
acls = ['commit', 'watchbugzilla', 'watchcommits']
try:
for pkg_collection in collections:
message = pkgdblib.update_pkg_poc(
SESSION,
pkg_name=packagename,
clt_name=pkg_collection,
pkg_poc=pkg_poc,
user=flask.g.fas_user,
)
flask.flash(message)
for acl in acls:
pkgdblib.set_acl_package(
SESSION,
pkg_name=packagename,
clt_name=pkg_collection,
pkg_user=pkg_poc,
acl=acl,
status='Approved',
user=flask.g.fas_user
)
SESSION.commit()
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
return flask.redirect(
flask.url_for('.package_info', package=packagename)
)
pkg_name=package.name,
clt_name=acl.collection.branchname,
pkg_poc='orphan',
user=flask.g.fas_user
)
flask.flash(
'You are no longer point of contact on branch: %s'
% collection)
except pkgdblib.PkgdbException, err:
flask.flash(err.message, 'error')
break
try:
SESSION.commit()
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(err.message, 'error')
return flask.redirect(
flask.url_for('.package_info', package=package.name))
@UI.route('/package/<package>/<collection>/retire', methods=('GET', 'POST'))
@packager_login_required
def package_retire(package, collection):
''' Gives the possibility to orphan or take a package. '''
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(SESSION, packagename)
def api_collection_status(collection):
'''
Update collection status
------------------------
Update the status of collection.
::
/api/collection/<collection branchname>/status/
Accept POST query only.
:arg collection_branchname: String of the collection branch name to change.
:arg collection_status: String of the status to change the collection to
Sample response:
::
{
"output": "ok",
"messages": ["Collection updated to \"EOL\""]
}
{
"output": "notok",
"error": ["You are not allowed to edit collections"]
}
'''
httpcode = 200
output = {}
clt_status = pkgdblib.get_status(SESSION, 'clt_status')['clt_status']
form = forms.CollectionStatusForm(
csrf_enabled=False,
clt_status=clt_status,
)
if form.validate_on_submit():
clt_branchname = form.collection_branchname.data
clt_status = form.collection_status.data
if collection == clt_branchname:
try:
message = pkgdblib.update_collection_status(
SESSION,
clt_branchname,
clt_status,
user=flask.g.fas_user
)
SESSION.commit()
output['output'] = 'ok'
output['messages'] = [message]
except pkgdblib.PkgdbException, err:
SESSION.rollback()
output['output'] = 'notok'
output['error'] = err.message
httpcode = 500
else:
output['output'] = 'notok'
output['error'] = "You're trying to update the " \
"wrong collection"
httpcode = 500
def api_collection_new():
'''
New collection
--------------
Create a new collection.
::
/api/collection/new/
Accept POST queries only.
:arg collection_name: String of the collection name to be created.
:arg collection_version: String of the version of the collection.
:arg collection_status: String of the name of the user owner of the
collection.
:arg collection_publishURLTemplate:
:arg collection_pendingURLTemplate:
:arg collection_summary: A summary description of the collection.
:arg collection_description: A description of the collection.
:arg collection_branchname: The short name of the collection (ie: F-18).
:arg collection_distTag: The dist tag used by rpm for this collection
(ie: .fc18).
:arg collection_git_branch_name: The git branch name for this collection
(ie: f18).
Sample response:
::
{
"output": "ok",
"messages": ["Collection F-20 created"]
}
{
"output": "notok",
"error": ["You are not allowed to create collections"]
}
'''
httpcode = 200
output = {}
clt_status = pkgdblib.get_status(SESSION, 'clt_status')['clt_status']
form = forms.AddCollectionForm(
csrf_enabled=False,
clt_status=clt_status,
)
if form.validate_on_submit():
clt_name = form.collection_name.data
clt_version = form.collection_version.data
clt_status = form.collection_status.data
clt_branchname = form.collection_branchname.data
clt_disttag = form.collection_distTag.data
clt_gitbranch = form.collection_git_branch_name.data
try:
message = pkgdblib.add_collection(
SESSION,
clt_name=clt_name,
clt_version=clt_version,
clt_status=clt_status,
clt_branchname=clt_branchname,
clt_disttag=clt_disttag,
clt_gitbranch=clt_gitbranch,
user=flask.g.fas_user,
)
SESSION.commit()
output['output'] = 'ok'
output['messages'] = [message]
# Apparently we're pretty tight on checks and looks like we cannot
# raise this exception in a normal situation
except pkgdblib.PkgdbException, err: # pragma: no cover
SESSION.rollback()
output['output'] = 'notok'
output['error'] = err.message
httpcode = 500
def api_acl_reassign():
'''
Reassign packages
-----------------
Reassign the specified packages from one user to another.
::
/api/package/acl/reassign/
Accept POST queries only.
:arg packages: List of strings of the package name to reassign.
:arg branches: List of strings of the branchname of the Collection on
which to reassign the point of contact.
:arg user_target: User name of the new point of contact.
Sample response:
::
{
"output": "ok",
"messages": ["User: $USER changed poc of package: $PACKAGE from "
"$PREVIOUS_POC to $NEW_POC on branch: $BRANCH"]
}
{
"output": "notok",
"error": ["You are not allowed to change the point of contact."]
}
'''
httpcode = 200
output = {}
packages = flask.request.form.get('packages', '').split(',')
branches = flask.request.form.get('branches', '').split(',')
user_target = flask.request.form.get('user_target', None)
if not packages or not branches or not user_target:
output['output'] = 'notok'
output['error'] = 'Invalid input submitted'
httpcode = 500
else:
try:
messages = []
for (package, branch) in itertools.product(packages, branches):
messages.append(
pkgdblib.update_pkg_poc(
session=SESSION,
pkg_name=package,
pkg_branch=branch,
pkg_poc=user_target,
user=flask.g.fas_user
)
)
SESSION.commit()
output['output'] = 'ok'
output['messages'] = messages
except pkgdblib.PkgdbException, err:
SESSION.rollback()
output['output'] = 'notok'
output['error'] = err.message
httpcode = 500
