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(str(err), 'error')
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(str(err), 'error')
def pending_acl_deny():
''' Deny all the pending acls for the user logged in. '''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
pending_acls = pkgdblib.get_pending_acl_user(SESSION,
flask.g.fas_user.username)
try:
for acl in pending_acls:
pkgdblib.set_acl_package(SESSION,
namespace=acl['namespace'],
pkg_name=acl['package'],
pkg_branch=acl['collection'],
pkg_user=acl['user'],
acl=acl['acl'],
status='Denied',
user=flask.g.fas_user)
SESSION.commit()
flask.flash('All ACLs denied')
# Let's keep this in although we should never see it
except PkgdbException as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(flask.url_for('.pending_acl'))
def pending_acl_deny():
''' Deny all the pending acls for the user logged in. '''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
pending_acls = pkgdblib.get_pending_acl_user(
SESSION, flask.g.fas_user.username)
try:
for acl in pending_acls:
pkgdblib.set_acl_package(
SESSION,
namespace=acl['namespace'],
pkg_name=acl['package'],
pkg_branch=acl['collection'],
pkg_user=acl['user'],
acl=acl['acl'],
status='Denied',
user=flask.g.fas_user
)
SESSION.commit()
flask.flash('All ACLs denied')
# Let's keep this in although we should never see it
except pkgdblib.PkgdbException, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
def giveup_acl(namespace, package, acl):
''' Request acls for a specific package. '''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
pkg_acl = pkgdblib.get_status(SESSION, 'pkg_acl')['pkg_acl']
if acl not in pkg_acl:
flask.flash('Invalid ACL provided %s.' % acl, 'errors')
return flask.render_template('msg.html')
try:
pkg = pkgdblib.search_package(
SESSION, namespace=namespace, 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', namespace=namespace, package=package))
pkg_branchs = set([
pkglist.collection.branchname
for pkglist in pkg.listings
if pkglist.collection.status in
['Active', 'Under Development'] and flask.g.fas_user.username in
[tmpacl.fas_name for tmpacl in pkglist.acls]
])
if not pkg_branchs:
flask.flash(
'No active branches found for you for the ACL: %s' % acl,
'error')
return flask.redirect(flask.url_for(
'.package_info', namespace=namespace, package=package))
for branch in pkg_branchs:
print package, namespace, branch, acl, flask.g.fas_user.username
try:
pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=package,
pkg_branch=branch,
pkg_user=flask.g.fas_user.username,
acl=acl,
status='Obsolete',
user=flask.g.fas_user,
)
flask.flash(
'Your ACL %s is obsoleted on branch %s of package %s'
% (acl, branch, package))
except pkgdblib.PkgdbException, err: # pragma: no cover
flask.flash(str(err), 'error')
SESSION.rollback()
try:
SESSION.commit()
# Keep it in, but normally we shouldn't hit this
except pkgdblib.PkgdbException, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
def package_give_acls(namespace, package):
''' Give acls to a specified user for a specific package. '''
try:
pkg = pkgdblib.search_package(SESSION,
namespace=namespace,
pkg_name=package,
limit=1)[0]
except IndexError:
flask.flash('No package found by this name', 'error')
return flask.redirect(flask.url_for('.list_packages'))
collections = [
pkglist.collection for pkglist in pkg.listings
if pkglist.collection.status != 'EOL'
]
acls = pkgdblib.get_status(SESSION)
form = pkgdb2.forms.SetAclPackageForm(
collections_obj=collections,
pkg_acl=acls['pkg_acl'],
acl_status=acls['acl_status'],
namespaces=acls['namespaces'],
)
form.pkgname.data = package
if str(form.namespace.data) in ['None', '']:
form.namespace.data = 'rpms'
if form.validate_on_submit():
pkg_branchs = form.branches.data
pkg_acls = form.acl.data
pkg_user = form.user.data
acl_status = form.acl_status.data
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
if acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=package,
pkg_branch=collec,
pkg_user=pkg_user,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
return flask.redirect(
flask.url_for('.package_info',
namespace=namespace,
package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(str(err), '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]
# Make sure the requester does not already have commit
pkg_branchs2 = []
for pkg_branch in pkg_branchs:
if pkgdblib.has_acls(SESSION, flask.g.fas_user.username, pkg.name,
pkg_branch, 'commit'):
flask.flash(
'You are already a co-maintainer on %s' % pkg_branch,
'error')
else:
pkg_branchs2.append(pkg_branch)
pkg_branchs = pkg_branchs2
if not pkg_branchs:
return flask.redirect(flask.url_for('.package_info', package=package))
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(str(err), 'error')
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)
pending_acls2 = []
if branch is not None:
for acls in pending_acls:
if acls['collection'] == branch:
pending_acls2.append(acls)
else:
for acls in pending_acls:
if acls['collection_status'] != 'EOL':
pending_acls2.append(acls)
pending_acls = pending_acls2
collections = set([item['collection'] for item in pending_acls])
status = pkgdblib.get_status(SESSION, ['pkg_acl', 'acl_status'])
form = pkgdb2.forms.UpdateAclPackageForm(
collections=collections,
pkg_acl_list=status['pkg_acl'],
acl_status=status['acl_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:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
if acl_status == 'Awaiting Review' and \
acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
pkg_branch=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))
# Let's keep this in although we should never see it
except pkgdblib.PkgdbException, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'errors')
def giveup_acl(package, acl):
''' Request acls for a specific package. '''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
pkg_acl = pkgdblib.get_status(SESSION, 'pkg_acl')['pkg_acl']
if acl not in pkg_acl:
flask.flash('Invalid ACL provided %s.' % acl, 'errors')
return flask.render_template('msg.html')
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_branchs = set([
pkglist.collection.branchname
for pkglist in pkg.listings
if pkglist.collection.status in
['Active', 'Under Development'] and flask.g.fas_user.username in
[tmpacl.fas_name for tmpacl in pkglist.acls]
])
if not pkg_branchs:
flask.flash(
'No active branches found for you for the ACL: %s' % acl,
'error')
return flask.redirect(
flask.url_for('.package_info', package=package))
for branch in pkg_branchs:
try:
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
pkg_branch=branch,
pkg_user=flask.g.fas_user.username,
acl=acl,
status='Obsolete',
user=flask.g.fas_user,
)
flask.flash(
'Your ACL %s is obsoleted on branch %s of package %s'
% (acl, branch, package))
except pkgdblib.PkgdbException, err:
flask.flash(str(err), 'error')
SESSION.rollback()
try:
SESSION.commit()
# Keep it in, but normally we shouldn't hit this
except pkgdblib.PkgdbException, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
def package_give_acls(namespace, package):
''' Give acls to a specified user for a specific package. '''
try:
pkg = pkgdblib.search_package(
SESSION, namespace=namespace, pkg_name=package, limit=1)[0]
except IndexError:
flask.flash('No package found by this name', 'error')
return flask.redirect(
flask.url_for('.list_packages'))
collections = [
pkglist.collection
for pkglist in pkg.listings
if pkglist.collection.status != 'EOL']
acls = pkgdblib.get_status(SESSION)
form = pkgdb2.forms.SetAclPackageForm(
collections_obj=collections,
pkg_acl=acls['pkg_acl'],
acl_status=acls['acl_status'],
namespaces=acls['namespaces'],
)
form.pkgname.data = package
if str(form.namespace.data) in ['None', '']:
form.namespace.data = 'rpms'
if form.validate_on_submit():
pkg_branchs = form.branches.data
pkg_acls = form.acl.data
pkg_user = form.user.data
acl_status = form.acl_status.data
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
if acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=package,
pkg_branch=collec,
pkg_user=pkg_user,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
return flask.redirect(flask.url_for(
'.package_info', namespace=namespace, package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(str(err), 'error')
def request_acl(namespace, package):
''' Request acls for a specific package. '''
try:
package_acl = pkgdblib.get_acl_package(SESSION, namespace, package)
package = pkgdblib.search_package(SESSION, namespace, package,
limit=1)[0]
except (NoResultFound, IndexError):
SESSION.rollback()
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
collections = [
acl.collection for acl in package_acl
if acl.collection.status in ['Active', 'Under Development']
]
pkg_acl = pkgdblib.get_status(SESSION, 'pkg_acl')['pkg_acl']
form = pkgdb2.forms.RequestAclPackageForm(collections=collections,
pkg_acl_list=pkg_acl)
if form.validate_on_submit():
pkg_branchs = form.branches.data
pkg_acls = form.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,
namespace=namespace,
pkg_name=package.name,
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')
return flask.redirect(
flask.url_for('.package_info',
namespace=package.namespace,
package=package.name))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(str(err), 'error')
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)
pending_acls2 = []
if branch is not None:
for acls in pending_acls:
if acls['collection'] == branch:
pending_acls2.append(acls)
else:
for acls in pending_acls:
if acls['collection_status'] != 'EOL':
pending_acls2.append(acls)
pending_acls = pending_acls2
collections = set([item['collection'] for item in pending_acls])
status = pkgdblib.get_status(SESSION, ['pkg_acl', 'acl_status'])
form = pkgdb2.forms.UpdateAclPackageForm(
collections=collections,
pkg_acl_list=status['pkg_acl'],
acl_status=status['acl_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:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
if acl_status == 'Awaiting Review' and \
acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
pkgdblib.set_acl_package(
SESSION,
pkg_name=package,
pkg_branch=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))
# Let's keep this in although we should never see it
except pkgdblib.PkgdbException, err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'errors')
def request_acl_all_branch(namespace, package, acl):
''' Request the specified ACL on all branches of the specified package.
'''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
pkg_acl = pkgdblib.get_status(SESSION, 'pkg_acl')['pkg_acl']
if acl not in pkg_acl:
flask.flash('Invalid ACL provided %s.' % acl, 'errors')
return flask.render_template('msg.html')
try:
pkg = pkgdblib.search_package(
SESSION, namespace=namespace, pkg_name=package, limit=1)[0]
except IndexError:
flask.flash('No package found by this name', 'error')
return flask.render_template('msg.html')
pkg_branchs = set([
pkglist.collection.branchname
for pkglist in pkg.listings
if pkglist.collection.status in ['Active', 'Under Development']
and pkglist.status == 'Approved'
])
for branch in pkg_branchs:
acl_status = 'Awaiting Review'
pkger_grp = APP.config.get('PKGER_GROUP', 'packager')
if acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
elif pkger_grp not in flask.g.fas_user.groups:
flask.flash(
'You must be a %s to apply to the ACL: %s on %s' % (
pkger_grp, acl, package), 'error')
try:
pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=package,
pkg_branch=branch,
pkg_user=flask.g.fas_user.username,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
flask.flash(
'ACL %s requested on branch %s' % (acl, branch))
SESSION.commit()
except PkgdbException as err:
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(flask.url_for(
'.package_info', namespace=namespace, package=package))
def request_acl(package):
''' Request acls for a specific package. '''
try:
package_acl = pkgdblib.get_acl_package(SESSION, package)
package = pkgdblib.search_package(SESSION, package, limit=1)[0]
except (NoResultFound, IndexError):
SESSION.rollback()
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
collections = [
acl.collection
for acl in package_acl
if acl.collection.status in ['Active', 'Under Development']
]
pkg_acl = pkgdblib.get_status(SESSION, 'pkg_acl')['pkg_acl']
form = pkgdb2.forms.RequestAclPackageForm(
collections=collections,
pkg_acl_list=pkg_acl
)
if form.validate_on_submit():
pkg_branchs = form.branches.data
pkg_acls = form.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.name,
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')
return flask.redirect(
flask.url_for('.package_info',
package=package.name))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(str(err), 'error')
def request_acl_all_branch(namespace, package, acl):
''' Request the specified ACL on all branches of the specified package.
'''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
pkg_acl = pkgdblib.get_status(SESSION, 'pkg_acl')['pkg_acl']
if acl not in pkg_acl:
flask.flash('Invalid ACL provided %s.' % acl, 'errors')
return flask.render_template('msg.html')
try:
pkg = pkgdblib.search_package(SESSION,
namespace=namespace,
pkg_name=package,
limit=1)[0]
except IndexError:
flask.flash('No package found by this name', 'error')
return flask.render_template('msg.html')
pkg_branchs = set([
pkglist.collection.branchname for pkglist in pkg.listings
if pkglist.collection.status in ['Active', 'Under Development']
and pkglist.status == 'Approved'
])
for branch in pkg_branchs:
acl_status = 'Awaiting Review'
pkger_grp = APP.config.get('PKGER_GROUP', 'packager')
if acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
elif pkger_grp not in flask.g.fas_user.groups:
flask.flash(
'You must be a %s to apply to the ACL: %s on %s' %
(pkger_grp, acl, package), 'error')
try:
pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=package,
pkg_branch=branch,
pkg_user=flask.g.fas_user.username,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
flask.flash('ACL %s requested on branch %s' % (acl, branch))
SESSION.commit()
except PkgdbException as err:
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(
flask.url_for('.package_info', namespace=namespace, package=package))
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]
# Make sure the requester does not already have commit
pkg_branchs2 = []
for pkg_branch in pkg_branchs:
if pkgdblib.has_acls(SESSION, flask.g.fas_user.username, pkg.name,
pkg_branch, 'commit'):
flask.flash('You are already a co-maintainer on %s' % pkg_branch,
'error')
else:
pkg_branchs2.append(pkg_branch)
pkg_branchs = pkg_branchs2
if not pkg_branchs:
return flask.redirect(flask.url_for('.package_info', package=package))
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(str(err), 'error')
def dropcommit_package(namespace, package):
''' Obsolete commit ACLs on a package.
This method can only be used for the user itself.
'''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
try:
pkg = pkgdblib.search_package(SESSION,
namespace=namespace,
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',
namespace=namespace,
package=package))
pkg_acls = ['commit']
pkg_branchs = set()
for pkglist in pkg.listings:
if pkglist.collection.status in ['Active', 'Under Development']:
for acl in pkglist.acls:
if acl.fas_name == flask.g.fas_user.username and \
acl.acl == 'commit' and acl.status == 'Approved':
pkg_branchs.add(pkglist.collection.branchname)
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=package,
pkg_branch=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status='Obsolete',
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
# Let's keep this in although we should never see it
except PkgdbException as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(
flask.url_for('.package_info', namespace=namespace, package=package))
def dropcommit_package(namespace, package):
''' Obsolete commit ACLs on a package.
This method can only be used for the user itself.
'''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
try:
pkg = pkgdblib.search_package(
SESSION, namespace=namespace, 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', namespace=namespace, package=package))
pkg_acls = ['commit']
pkg_branchs = set()
for pkglist in pkg.listings:
if pkglist.collection.status in [
'Active', 'Under Development']:
for acl in pkglist.acls:
if acl.fas_name == flask.g.fas_user.username and \
acl.acl == 'commit' and acl.status == 'Approved':
pkg_branchs.add(pkglist.collection.branchname)
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=package,
pkg_branch=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status='Obsolete',
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash('ACLs updated')
# Let's keep this in although we should never see it
except PkgdbException as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(flask.url_for(
'.package_info', namespace=namespace, package=package))
def watch_package(namespace, package):
''' Request watch* ACLs on a package.
Anyone can request these ACLs, no need to be a packager.
'''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
try:
pkg = pkgdblib.search_package(SESSION,
namespace=namespace,
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',
namespace=namespace,
package=package))
pkg_acls = ['watchcommits', 'watchbugzilla']
pkg_branchs = set([
pkglist.collection.branchname for pkglist in pkg.listings
if pkglist.collection.status in ['Active', 'Under Development']
and pkglist.status == 'Approved'
])
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
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 PkgdbException as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(
flask.url_for('.package_info', namespace=namespace, package=package))
def request_acl(package):
''' Request acls for a specific package. '''
collections = pkgdblib.search_collection(
SESSION, '*', 'Under Development')
collections.extend(pkgdblib.search_collection(SESSION, '*', 'Active'))
pkg_acl = pkgdblib.get_status(SESSION, 'pkg_acl')['pkg_acl']
form = pkgdb2.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,
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')
return flask.redirect(
flask.url_for('.package_info',
package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(str(err), 'error')
def watch_package(namespace, package):
''' Request watch* ACLs on a package.
Anyone can request these ACLs, no need to be a packager.
'''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
try:
pkg = pkgdblib.search_package(
SESSION, namespace=namespace, 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', namespace=namespace, package=package))
pkg_acls = ['watchcommits', 'watchbugzilla']
pkg_branchs = set([
pkglist.collection.branchname
for pkglist in pkg.listings
if pkglist.collection.status in ['Active', 'Under Development']
and pkglist.status == 'Approved'
])
try:
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
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 PkgdbException as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(flask.url_for(
'.package_info', namespace=namespace, package=package))
def request_acl(package):
''' Request acls for a specific package. '''
collections = pkgdblib.search_collection(SESSION, '*', 'Under Development')
collections.extend(pkgdblib.search_collection(SESSION, '*', 'Active'))
pkg_acl = pkgdblib.get_status(SESSION, 'pkg_acl')['pkg_acl']
form = pkgdb2.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,
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')
return flask.redirect(
flask.url_for('.package_info', package=package))
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(str(err), 'error')
def unwatch_package(package):
''' Obsolete watch* ACLs on a package.
This method can only be used for the user itself.
'''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
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 = set([
pkglist.collection.branchname
for pkglist in pkg.listings
if pkglist.collection.status in ['Active', 'Under Development']])
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='Obsolete',
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(str(err), 'error')
def unwatch_package(package):
''' Obsolete watch* ACLs on a package.
This method can only be used for the user itself.
'''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
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 = set([
pkglist.collection.branchname
for pkglist in pkg.listings
if pkglist.collection.status in ['Active', 'Under Development']])
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='Obsolete',
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(str(err), 'error')
def api_acl_update():
"""
Update package ACL
------------------
Update the ACL for a given package.
::
/api/package/acl/
Accept POST queries only.
:arg pkgname: String of the package name.
:arg branches: List of strings with the name of the branches to change,
update.
:arg 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 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 = pkgdblib.get_status(SESSION, ["pkg_acl", "acl_status"])
collections = pkgdblib.search_collection(SESSION, "*", "Under Development")
collections.extend(pkgdblib.search_collection(SESSION, "*", "Active"))
form = forms.SetAclPackageForm(
csrf_enabled=False,
collections=[col.branchname for col in collections],
pkg_acl=status["pkg_acl"],
acl_status=status["acl_status"],
)
if form.validate_on_submit():
pkg_name = form.pkgname.data
pkg_branch = form.branches.data
pkg_acl = form.acl.data
acl_status = form.acl_status.data
pkg_user = form.user.data
try:
messages = []
for (branch, acl) in itertools.product(pkg_branch, pkg_acl):
acl_status2 = acl_status
if acl_status2 == "Awaiting Review" and acl in APP.config["AUTO_APPROVE"]:
acl_status2 = "Approved"
message = pkgdblib.set_acl_package(
SESSION,
pkg_name=pkg_name,
pkg_branch=branch,
acl=acl,
status=acl_status2,
pkg_user=pkg_user,
user=flask.g.fas_user,
)
if message:
messages.append(message)
else:
messages.append("Nothing to update on branch: %s for acl: %s" % (branch, acl))
SESSION.commit()
output["output"] = "ok"
output["messages"] = messages
except pkgdblib.PkgdbException, err:
SESSION.rollback()
output["output"] = "notok"
output["error"] = str(err)
httpcode = 500
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 = pkgdblib.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.split(',')
acl_status = form.acl_status.data
pkg_user = form.pkg_user.data
try:
messages = []
for (acl, branch) in itertools.product(pkg_acl, pkg_branch):
message = pkgdblib.set_acl_package(
SESSION,
pkg_name=pkg_name,
pkg_branch=branch,
acl=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'] = str(err)
httpcode = 500
def comaintain_package(namespace, package):
''' Asks for ACLs to co-maintain a package.
You need to be a packager to request co-maintainership.
'''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
# This is really wearing belt and suspenders, the decorator above
# should take care of this
pkger_grp = APP.config.get('PKGER_GROUP', 'packager')
if pkger_grp not in flask.g.fas_user.groups: # pragma: no cover
flask.flash(
'You must be a %s to apply to be a comaintainer' % pkger_grp,
'errors')
return flask.redirect(flask.url_for(
'.package_info', package=package))
try:
pkg = pkgdblib.search_package(
SESSION, namespace=namespace, 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', namespace=namespace, package=package))
pkg_acls = ['commit', 'watchcommits', 'watchbugzilla']
pkg_branchs = set([
pkglist.collection.branchname
for pkglist in pkg.listings
if pkglist.collection.status in ['Active', 'Under Development']
and pkglist.status == 'Approved'
])
# Make sure the requester does not already have commit
pkg_branchs2 = []
for pkg_branch in pkg_branchs:
if pkgdblib.has_acls(
SESSION, flask.g.fas_user.username, pkg.namespace,
pkg.name, acl='commit', branch=pkg_branch):
flask.flash(
'You are already a co-maintainer on %s' % pkg_branch,
'error')
else:
pkg_branchs2.append(pkg_branch)
pkg_branchs = pkg_branchs2
if not pkg_branchs:
return flask.redirect(flask.url_for(
'.package_info', namespace=namespace, package=package))
try:
msgs = []
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
acl_status = 'Awaiting Review'
if acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
msg = pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=package,
pkg_branch=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
if msg:
msgs.append(msg)
SESSION.commit()
if msgs:
flask.flash('ACLs updated')
else:
flask.flash('Nothing to update')
# Let's keep this in although we should never see it
except PkgdbException as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(flask.url_for(
'.package_info', namespace=namespace, package=package))
def update_acl(package, update_acl):
''' Update the acls of 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')
statues = pkgdblib.get_status(SESSION)
planned_acls = set(statues['pkg_acl'])
acl_status = list(set(statues['acl_status']))
acl_status.insert(0, '')
if update_acl not in planned_acls:
flask.flash('Invalid ACL to update.', 'errors')
return flask.redirect(
flask.url_for('.package_info', package=package.name))
branches = {}
branches_inv = {}
commit_acls = {}
admins = {}
committers = []
for pkg in package_acl:
if pkg.collection.status == 'EOL': # pragma: no cover
continue
collection_name = '%s %s' % (pkg.collection.name,
pkg.collection.version)
if collection_name not in branches:
branches[collection_name] = pkg.collection.branchname
if pkg.collection.branchname not in branches_inv:
branches_inv[pkg.collection.branchname] = collection_name
for acl in pkg.acls:
if acl.acl == 'approveacls' and acl.status == 'Approved':
if acl.fas_name not in admins:
admins[acl.fas_name] = set()
admins[acl.fas_name].add(collection_name)
if acl.acl != update_acl:
continue
committers.append(acl.fas_name)
if acl.fas_name not in commit_acls:
commit_acls[acl.fas_name] = {}
if collection_name not in commit_acls[acl.fas_name]:
commit_acls[acl.fas_name][collection_name] = {}
commit_acls[acl.fas_name][collection_name][acl.acl] = \
acl.status
for aclname in planned_acls:
for user in commit_acls:
if collection_name in commit_acls[user] and \
aclname not in commit_acls[user][collection_name]:
commit_acls[user][collection_name][aclname] = None
# If the user is not an admin, he/she can only access his/her ACLs
username = flask.g.fas_user.username
if username not in admins and not is_pkgdb_admin(flask.g.fas_user):
tmp = {username: []}
if username in commit_acls:
tmp = {username: commit_acls[username]}
commit_acls = tmp
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
sub_acls = flask.request.values.getlist('acls')
sub_users = flask.request.values.getlist('user')
sub_branches = flask.request.values.getlist('branch')
changed = False
if sub_acls and len(sub_acls) == (len(sub_users) * len(sub_branches)):
cnt = 0
for cnt_u in range(len(sub_users)):
for cnt_b in range(len(sub_branches)):
lcl_acl = sub_acls[cnt]
lcl_user = sub_users[cnt_u]
lcl_branch = sub_branches[cnt_b]
if lcl_acl not in acl_status:
flask.flash('Invalid ACL: %s' % lcl_acl, 'error')
cnt += 1
continue
if lcl_user not in commit_acls:
flask.flash('Invalid user: %s' % lcl_user, 'error')
cnt += 1
continue
if lcl_branch not in branches_inv or (
branches_inv[lcl_branch] in commit_acls[lcl_user]
and commit_acls[lcl_user][branches_inv[lcl_branch]]
[update_acl] == lcl_acl):
cnt += 1
continue
if not lcl_acl:
if branches_inv[lcl_branch] \
not in commit_acls[lcl_user]:
cnt += 1
continue
elif branches_inv[lcl_branch] \
in commit_acls[lcl_user] \
and username != lcl_user:
flask.flash('Only the user can remove his/her ACL',
'error')
cnt += 1
continue
try:
pkgdblib.set_acl_package(
SESSION,
pkg_name=package.name,
pkg_branch=lcl_branch,
pkg_user=lcl_user,
acl=update_acl,
status=lcl_acl,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash("%s's %s ACL updated on %s" %
(lcl_user, update_acl, lcl_branch))
changed = True
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(str(err), 'error')
cnt += 1
SESSION.commit()
if not changed:
flask.flash('Nothing to update')
return flask.redirect(
flask.url_for('.package_info', package=package.name))
else:
flask.flash('Invalid input submitted', 'error')
def comaintain_package(namespace, package):
''' Asks for ACLs to co-maintain a package.
You need to be a packager to request co-maintainership.
'''
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
# This is really wearing belt and suspenders, the decorator above
# should take care of this
pkger_grp = APP.config.get('PKGER_GROUP', 'packager')
if pkger_grp not in flask.g.fas_user.groups: # pragma: no cover
flask.flash(
'You must be a %s to apply to be a comaintainer' % pkger_grp,
'errors')
return flask.redirect(
flask.url_for('.package_info', package=package))
try:
pkg = pkgdblib.search_package(SESSION,
namespace=namespace,
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',
namespace=namespace,
package=package))
pkg_acls = ['commit', 'watchcommits', 'watchbugzilla']
pkg_branchs = set([
pkglist.collection.branchname for pkglist in pkg.listings
if pkglist.collection.status in ['Active', 'Under Development']
and pkglist.status == 'Approved'
])
# Make sure the requester does not already have commit
pkg_branchs2 = []
for pkg_branch in pkg_branchs:
if pkgdblib.has_acls(SESSION,
flask.g.fas_user.username,
pkg.namespace,
pkg.name,
acl='commit',
branch=pkg_branch):
flask.flash(
'You are already a co-maintainer on %s' % pkg_branch,
'error')
else:
pkg_branchs2.append(pkg_branch)
pkg_branchs = pkg_branchs2
if not pkg_branchs:
return flask.redirect(
flask.url_for('.package_info',
namespace=namespace,
package=package))
try:
msgs = []
for (collec, acl) in itertools.product(pkg_branchs, pkg_acls):
acl_status = 'Awaiting Review'
if acl in APP.config['AUTO_APPROVE']:
acl_status = 'Approved'
msg = pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=package,
pkg_branch=collec,
pkg_user=flask.g.fas_user.username,
acl=acl,
status=acl_status,
user=flask.g.fas_user,
)
if msg:
msgs.append(msg)
SESSION.commit()
if msgs:
flask.flash('ACLs updated')
else:
flask.flash('Nothing to update')
# Let's keep this in although we should never see it
except PkgdbException as err: # pragma: no cover
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(
flask.url_for('.package_info', namespace=namespace, package=package))
def package_give(package, full=True):
''' Gives the PoC of a package to someone else. '''
if not bool(full) or str(full) in ['0', 'False']:
full = False
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')
# 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
elif acl.collection.status != 'EOL':
collect_name.append(acl.collection.branchname)
form = pkgdb2.forms.GivePoCForm(collections=collect_name)
acls = ['commit', 'watchbugzilla', 'watchcommits', 'approveacls']
if form.validate_on_submit():
collections = form.branches.data
pkg_poc = form.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,
pkg_branch=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,
pkg_branch=pkg_collection,
pkg_user=pkg_poc,
acl=acl,
status='Approved',
user=flask.g.fas_user)
SESSION.commit()
except pkgdblib.PkgdbBugzillaException, err: # pragma: no cover
APP.logger.exception(err)
flask.flash(str(err), 'error')
SESSION.rollback()
except pkgdblib.PkgdbException, err:
SESSION.rollback()
flask.flash(str(err), 'error')
def api_acl_update():
'''
Update package ACL
------------------
Update the ACL for a given package.
::
/api/package/acl/
Accepts POST queries only.
:arg pkgname: String of the package name.
:arg branches: List of strings with the name of the branches to change,
update.
:arg 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 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.
:kwarg namespace: The namespace of the packages (defaults to ``rpms``).
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 = pkgdblib.get_status(
SESSION, ['pkg_acl', 'acl_status', 'namespaces'])
collections = pkgdblib.search_collection(
SESSION, '*', 'Under Development')
collections.extend(pkgdblib.search_collection(SESSION, '*', 'Active'))
form = forms.SetAclPackageForm(
csrf_enabled=False,
collections=[col.branchname for col in collections],
pkg_acl=status['pkg_acl'],
acl_status=status['acl_status'],
namespaces=status['namespaces'],
)
if str(form.namespace.data) in ['None', '']:
form.namespace.data = 'rpms'
if form.validate_on_submit():
namespace = form.namespace.data
pkg_name = form.pkgname.data
pkg_branch = form.branches.data
pkg_acl = form.acl.data
acl_status = form.acl_status.data
pkg_user = form.user.data
try:
messages = []
for (branch, acl) in itertools.product(pkg_branch, pkg_acl):
acl_status2 = acl_status
if acl_status2 == 'Awaiting Review' and \
acl in APP.config['AUTO_APPROVE']:
acl_status2 = 'Approved'
message = pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=pkg_name,
pkg_branch=branch,
acl=acl,
status=acl_status2,
pkg_user=pkg_user,
user=flask.g.fas_user,
)
if message:
messages.append(message)
else:
messages.append(
'Nothing to update on branch: %s for acl: %s' %
(branch, acl))
SESSION.commit()
output['output'] = 'ok'
output['messages'] = messages
except PkgdbException as err:
SESSION.rollback()
output['output'] = 'notok'
output['error'] = str(err)
httpcode = 500
else:
output['output'] = 'notok'
output['error'] = 'Invalid input submitted'
if form.errors:
detail = []
for error in form.errors:
detail.append('%s: %s' % (error,
'; '.join(form.errors[error])))
output['error_detail'] = detail
httpcode = 500
jsonout = flask.jsonify(output)
jsonout.status_code = httpcode
return jsonout
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 = pkgdblib.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.split(',')
acl_status = form.acl_status.data
pkg_user = form.pkg_user.data
try:
messages = []
for (acl, branch) in itertools.product(pkg_acl, pkg_branch):
message = pkgdblib.set_acl_package(
SESSION,
pkg_name=pkg_name,
pkg_branch=branch,
acl=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'] = str(err)
httpcode = 500
def update_acl(namespace, package, update_acl):
''' Update the acls of a package. '''
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(
SESSION, namespace, packagename)
package = pkgdblib.search_package(
SESSION, namespace, packagename, limit=1)[0]
except (NoResultFound, IndexError):
SESSION.rollback()
flask.flash('No package of this name found.', 'errors')
return flask.render_template('msg.html')
statues = pkgdblib.get_status(SESSION)
planned_acls = set(statues['pkg_acl'])
acl_status = list(set(statues['acl_status']))
acl_status.insert(0, '')
if update_acl not in planned_acls:
flask.flash('Invalid ACL to update.', 'errors')
return flask.redirect(flask.url_for(
'.package_info',
namespace=package.namespace,
package=package.name)
)
branches = {}
branches_inv = {}
commit_acls = {}
admins = {}
committers = []
for pkg in package_acl:
if pkg.collection.status == 'EOL': # pragma: no cover
continue
collection_name = '%s %s' % (
pkg.collection.name, pkg.collection.version)
if collection_name not in branches:
branches[collection_name] = pkg.collection.branchname
if pkg.collection.branchname not in branches_inv:
branches_inv[pkg.collection.branchname] = collection_name
for acl in pkg.acls:
if acl.acl == 'approveacls' and acl.status == 'Approved':
if acl.fas_name not in admins:
admins[acl.fas_name] = set()
admins[acl.fas_name].add(collection_name)
if acl.acl != update_acl:
continue
committers.append(acl.fas_name)
if acl.fas_name not in commit_acls:
commit_acls[acl.fas_name] = {}
if collection_name not in commit_acls[acl.fas_name]:
commit_acls[acl.fas_name][collection_name] = {}
commit_acls[acl.fas_name][collection_name][acl.acl] = \
acl.status
for aclname in planned_acls:
for user in commit_acls:
if collection_name in commit_acls[user] and \
aclname not in commit_acls[user][collection_name]:
commit_acls[user][collection_name][aclname] = None
# If the user is not an admin, he/she can only access his/her ACLs
username = flask.g.fas_user.username
if username not in admins and not is_pkgdb_admin(flask.g.fas_user):
tmp = {username: []}
if username in commit_acls:
tmp = {username: commit_acls[username]}
commit_acls = tmp
form = pkgdb2.forms.ConfirmationForm()
if form.validate_on_submit():
sub_acls = flask.request.values.getlist('acls')
sub_users = flask.request.values.getlist('user')
sub_branches = flask.request.values.getlist('branch')
changed = False
if sub_acls and len(sub_acls) == (len(sub_users) * len(sub_branches)):
cnt = 0
for cnt_u in range(len(sub_users)):
for cnt_b in range(len(sub_branches)):
lcl_acl = sub_acls[cnt]
lcl_user = sub_users[cnt_u]
lcl_branch = sub_branches[cnt_b]
if lcl_acl not in acl_status:
flask.flash('Invalid ACL: %s' % lcl_acl, 'error')
cnt += 1
continue
if lcl_user not in commit_acls:
flask.flash('Invalid user: %s' % lcl_user, 'error')
cnt += 1
continue
if lcl_branch not in branches_inv or (
branches_inv[lcl_branch] in commit_acls[lcl_user]
and commit_acls[lcl_user][
branches_inv[lcl_branch]][
update_acl] == lcl_acl):
cnt += 1
continue
if not lcl_acl:
if branches_inv[lcl_branch] \
not in commit_acls[lcl_user]:
cnt += 1
continue
elif branches_inv[lcl_branch] \
in commit_acls[lcl_user] \
and username != lcl_user:
flask.flash(
'Only the user can remove his/her ACL',
'error')
cnt += 1
continue
try:
pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=package.name,
pkg_branch=lcl_branch,
pkg_user=lcl_user,
acl=update_acl,
status=lcl_acl,
user=flask.g.fas_user,
)
SESSION.commit()
flask.flash("%s's %s ACL updated on %s" % (
lcl_user, update_acl, lcl_branch))
changed = True
except PkgdbException as err:
SESSION.rollback()
flask.flash(str(err), 'error')
cnt += 1
SESSION.commit()
if not changed:
flask.flash('Nothing to update')
return flask.redirect(flask.url_for(
'.package_info',
namespace=package.namespace,
package=package.name)
)
else:
flask.flash('Invalid input submitted', 'error')
return flask.render_template(
'acl_update.html',
acl=update_acl,
acl_status=acl_status,
package=package,
form=form,
branches=branches,
commit_acls=commit_acls,
admins=admins,
committers=committers,
)
def package_give(namespace, package, full=True):
''' Gives the PoC of a package to someone else. '''
if not bool(full) or str(full) in ['0', 'False']:
full = False
packagename = package
package = None
try:
package_acl = pkgdblib.get_acl_package(
SESSION, namespace, packagename)
package = pkgdblib.search_package(
SESSION, namespace, packagename, limit=1)[0]
except (NoResultFound, IndexError):
SESSION.rollback()
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
elif acl.collection.status != 'EOL':
collect_name.append(acl.collection.branchname)
form = pkgdb2.forms.GivePoCForm(collections=collect_name)
acls = ['commit', 'watchbugzilla', 'watchcommits', 'approveacls']
if form.validate_on_submit():
collections = form.branches.data
pkg_poc = form.poc.data
if pkg_poc.startswith('group::'):
acls = ['commit', 'watchbugzilla', 'watchcommits']
try:
for pkg_collection in collections:
message = pkgdblib.update_pkg_poc(
SESSION,
namespace=namespace,
pkg_name=packagename,
pkg_branch=pkg_collection,
pkg_poc=pkg_poc,
user=flask.g.fas_user,
)
flask.flash(message)
for acl in acls:
pkgdblib.set_acl_package(
SESSION,
namespace=namespace,
pkg_name=packagename,
pkg_branch=pkg_collection,
pkg_user=pkg_poc,
acl=acl,
status='Approved',
user=flask.g.fas_user
)
SESSION.commit()
except pkgdblib.exceptions.PkgdbBugzillaException as err: # pragma: no cover
APP.logger.exception(err)
flask.flash(str(err), 'error')
SESSION.rollback()
except PkgdbException as err:
SESSION.rollback()
flask.flash(str(err), 'error')
return flask.redirect(flask.url_for(
'.package_info', namespace=namespace, package=packagename)
)
return flask.render_template(
'package_give.html',
full=full,
form=form,
packagename=packagename,
namespace=namespace,
)