def create_new_adi(self, wanted_requests, split=False):
source_projects_expand = self.config.get('source_projects_expand',
'').split()
# if we don't call it, there is no invalidate function added
requests = self.api.get_open_requests()
if len(wanted_requests):
requests = []
rf = RequestFinder(self.api)
for p in wanted_requests:
requests.append(rf.load_request(p))
splitter = RequestSplitter(self.api, requests, in_ring=False)
splitter.filter_add('./action[@type="submit" or @type="delete"]')
if len(wanted_requests):
splitter.filter_add_requests([str(p) for p in wanted_requests])
# wanted_requests forces all requests into a single group.
else:
if split:
splitter.group_by('./@id')
else:
splitter.group_by('./action/source/@project')
splitter.split()
for group in sorted(splitter.grouped.keys()):
print(Fore.YELLOW + (group if group != '' else 'wanted') +
Fore.RESET)
name = None
for request in splitter.grouped[group]['requests']:
request_id = int(request.get('id'))
target = request.find('./action/target')
target_package = target.get('package')
line = '- {} {}{:<30}{}'.format(request_id, Fore.CYAN,
target_package, Fore.RESET)
message = self.api.ignore_format(request_id)
if message:
print(line + '\n' + Fore.WHITE + message + Fore.RESET)
continue
# Auto-superseding request in adi command
stage_info, code = self.api.update_superseded_request(request)
if stage_info:
print(line +
' ({})'.format(SupersedeCommand.CODE_MAP[code]))
continue
# Only create staging projec the first time a non superseded
# request is processed from a particular group.
if name is None:
use_frozenlinks = group in source_projects_expand and not split
name = self.api.create_adi_project(None, use_frozenlinks,
group)
if not self.api.rq_to_prj(request_id, name):
return False
print(line + Fore.GREEN + ' (staged in {})'.format(name) +
Fore.RESET)
def perform(self, packages, move=False, by_dp=False, split=False):
"""
Perform the list command
"""
if len(packages):
requests = set()
if move:
items = RequestFinder.find_staged_sr(packages,
self.api).items()
print(items)
for request, request_project in items:
staging_project = request_project['staging']
self.api.rm_from_prj(staging_project, request_id=request)
self.api.add_review(request,
by_group=self.api.cstaging_group,
msg='Please recheck')
else:
items = RequestFinder.find_sr(packages, self.api).items()
for request, request_project in items:
requests.add(request)
self.create_new_adi(requests, split=split)
else:
self.check_adi_projects()
if self.api.is_user_member_of(self.api.user,
self.api.cstaging_group):
self.create_new_adi((), by_dp=by_dp, split=split)
def perform(self, requests, move=False, from_=None, no_freeze=False):
"""
Select package and move it accordingly by arguments
:param target_project: project we want to target
:param requests: requests we are working with
:param move: wether to move the requests or not
:param from_: location where from move the requests
"""
if self.api.is_adi_project(self.target_project):
no_freeze = True
# If the project is not frozen enough yet freeze it
if not (no_freeze or self.api.prj_frozen_enough(self.target_project)):
print('Freeze the prj first')
return False
# FreezeCommand(self.api).perform(self.target_project)
# picks new candidate requests only if it's not to move requests
# ie. the review state of staging-project must be new if newcand is True
newcand = not move
for request in RequestFinder.find_sr(requests, self.api, newcand):
if not self.select_request(request, move, from_):
return False
# Notify everybody about the changes
self.api.update_status_comments(self.target_project, 'select')
for fprj in self.affected_projects:
self.api.update_status_comments(fprj, 'select')
# now make sure we enable the prj if the prj contains any ringed package
self.api.build_switch_staging_project(self.target_project)
return True
def perform(self, packages, cleanup, message):
"""
Remove request from staging project
:param packages: packages/requests to delete from staging projects
"""
if cleanup:
obsolete = self.api.project_status_requests(
'obsolete', self.filter_obsolete)
if len(obsolete) > 0:
print('Cleanup {} obsolete requests'.format(len(obsolete)))
packages += tuple(obsolete)
affected_projects = set()
for request, request_project in RequestFinder.find_staged_sr(
packages, self.api).items():
staging_project = request_project['staging']
affected_projects.add(staging_project)
print('Unselecting "{}" from "{}"'.format(request,
staging_project))
self.api.rm_from_prj(staging_project, request_id=request)
req = get_request(self.api.apiurl, str(request))
if message:
self.api.add_ignored_request(request, message)
self.comment.add_comment(request_id=str(request),
comment=message)
elif req.state.name in ('new', 'review'):
print(
' Consider marking the request ignored to let others know not to restage.'
)
# Notify everybody about the changes
for prj in affected_projects:
self.api.update_status_or_deactivate(prj, 'unselect')
def perform(self, requests, cleanup=False):
"""
Unignore a request by removing from ignore list.
"""
requests_ignored = self.api.get_ignored_requests()
length = len(requests_ignored)
if len(requests) == 1 and requests[0] == 'all':
requests_ignored = {}
else:
for request_id in RequestFinder.find_sr(requests, self.api):
if request_id in requests_ignored.keys():
print('{}: unignored'.format(request_id))
del requests_ignored[request_id]
self.api.del_ignored_request(request_id)
self.comment.add_comment(request_id=str(request_id),
comment=self.MESSAGE)
if cleanup:
now = datetime.now()
for request_id in set(requests_ignored):
request = get_request(self.api.apiurl, str(request_id))
if request.state.name not in ('new', 'review'):
changed = dateutil.parser.parse(request.state.when)
diff = now - changed
if diff.days > 3:
print('Removing {} which was {} {} days ago'.format(
request_id, request.state.name, diff.days))
self.api.del_ignored_request(request_id)
return True
def perform(self, target_project, requests, move=False, from_=None):
"""
Select package and move it accordingly by arguments
:param target_project: project we want to target
:param requests: requests we are working with
:param move: wether to move the requests or not
:param from_: location where from move the requests
"""
# If the project is not frozen enough yet freeze it
if not self.api.prj_frozen_enough(target_project):
print('Freeze the prj first')
return False
# FreezeCommand(self.api).perform(target_project)
self.target_project = target_project
for request in RequestFinder.find_sr(requests, self.api):
if not self.select_request(request, move, from_):
return False
# Notify everybody about the changes
self.api.update_status_comments(target_project, 'select')
for fprj in self.affected_projects:
self.api.update_status_comments(fprj, 'select')
# now make sure we enable the prj if the prj contains any ringed package
self.api.build_switch_staging_project(target_project)
return True
def perform(self, requests, message=None):
"""
Ignore a request from "list" and "adi" commands until unignored.
"""
requests_ignored = self.api.get_ignored_requests()
length = len(requests_ignored)
for request_id in RequestFinder.find_sr(requests, self.api):
if request_id in requests_ignored:
print('{}: already ignored'.format(request_id))
continue
print('{}: ignored'.format(request_id))
requests_ignored[request_id] = message
comment = message if message else self.MESSAGE
self.comment.add_comment(request_id=str(request_id), comment=comment)
diff = len(requests_ignored) - length
if diff > 0:
self.api.set_ignored_requests(requests_ignored)
print('Ignored {} requests'.format(diff))
else:
print('No new requests to ignore')
return True
def perform(self, requests, move=False, filter_from=None, no_freeze=False):
"""
Select package and move it accordingly by arguments
:param target_project: project we want to target
:param requests: requests we are working with
:param move: wether to move the requests or not
:param filter_from: filter request list to only those from a specific staging
"""
if self.api.is_adi_project(self.target_project):
no_freeze = True
# If the project is not frozen enough yet freeze it
if not (no_freeze or self.api.prj_frozen_enough(self.target_project)):
print('Freeze the prj first')
return False
# FreezeCommand(self.api).perform(self.target_project)
# picks new candidate requests only if it's not to move requests
# ie. the review state of staging-project must be new if newcand is True
newcand = not move
requests = RequestFinder.find_sr(requests, self.api, newcand)
requests_count = len(requests)
for index, request in enumerate(requests, start=1):
print('({}/{}) '.format(index, requests_count), end='')
if not self.select_request(request, move, filter_from):
return False
# Notify everybody about the changes
self.api.update_status_or_deactivate(self.target_project, 'select')
for fprj in self.affected_projects:
self.api.update_status_or_deactivate(fprj, 'select')
return True
def perform(self, requests, message=None):
"""
Ignore a request from "list" and "adi" commands until unignored.
"""
requests_ignored = self.api.get_ignored_requests()
length = len(requests_ignored)
for request_id in RequestFinder.find_sr(requests, self.api):
if request_id in requests_ignored:
print('{}: already ignored'.format(request_id))
continue
print('{}: ignored'.format(request_id))
requests_ignored[request_id] = message
comment = message if message else self.MESSAGE
self.comment.add_comment(request_id=str(request_id),
comment=comment)
diff = len(requests_ignored) - length
if diff > 0:
self.api.set_ignored_requests(requests_ignored)
print('Ignored {} requests'.format(diff))
else:
print('No new requests to ignore')
return True
def perform(self, packages):
"""
Repair request in staging project or move it out
:param packages: packages/requests to repair in staging projects
"""
for reqid in RequestFinder.find_sr(packages, self.api):
self.repair(reqid)
def perform(self, packages):
"""
Repair request in staging project or move it out
:param packages: packages/requests to repair in staging projects
"""
for reqid in RequestFinder.find_sr(packages, self.api):
self.repair(reqid)
def perform(self, requests, message=None):
"""
Ignore a request from "list" and "adi" commands until unignored.
"""
for request_id in RequestFinder.find_sr(requests, self.api):
print('{}: ignored'.format(request_id))
comment = message if message else self.MESSAGE
self.api.add_ignored_request(request_id, comment)
self.comment.add_comment(request_id=str(request_id), comment=comment)
return True
def perform(self, packages, cleanup=False):
"""
Repair request in staging project or move it out
:param packages: packages/requests to repair in staging projects
"""
if cleanup:
untracked = self.api.project_status_requests('untracked')
if len(untracked) > 0:
print('Cleanup {} untracked requests'.format(len(untracked)))
packages += tuple(untracked)
for reqid in RequestFinder.find_sr(packages, self.api):
self.repair(reqid)
def perform(self, packages, move=False, by_dp=False, split=False):
"""
Perform the list command
"""
if len(packages):
requests = set()
if move:
items = RequestFinder.find_staged_sr(packages, self.api).items()
print(items)
for request, request_project in items:
staging_project = request_project['staging']
self.api.rm_from_prj(staging_project, request_id=request)
self.api.add_review(request, by_group=self.api.cstaging_group, msg='Please recheck')
else:
items = RequestFinder.find_sr(packages, self.api).items()
for request, request_project in items:
requests.add(request)
self.create_new_adi(requests, split=split)
else:
self.check_adi_projects()
if self.api.is_user_member_of(self.api.user, self.api.cstaging_group):
self.create_new_adi((), by_dp=by_dp, split=split)
def perform(self, packages, cleanup=False):
"""
Repair request in staging project or move it out
:param packages: packages/requests to repair in staging projects
"""
if cleanup:
untracked = self.api.project_status_requests('untracked')
if len(untracked) > 0:
print('Cleanup {} untracked requests'.format(len(untracked)))
packages += tuple(untracked)
for reqid in RequestFinder.find_sr(packages, self.api):
self.repair(reqid)
def perform(self, packages):
"""
Perform the list command
"""
if len(packages):
requests = set()
for request, request_project in RequestFinder.find_sr(packages,
self.api).items():
requests.add(request)
self.create_new_adi(requests)
else:
self.check_adi_projects()
if self.api.is_user_member_of(self.api.user, 'factory-staging'):
self.create_new_adi(())
def perform(self, packages):
"""
Perform the list command
"""
if len(packages):
requests = set()
for request, request_project in RequestFinder.find_sr(
packages, self.api).items():
requests.add(request)
self.create_new_adi(requests)
else:
self.check_adi_projects()
if self.api.is_user_member_of(self.api.user, 'factory-staging'):
self.create_new_adi(())
def perform(self,
requests,
move=False,
filter_from=None,
no_freeze=False,
remove_exclusion=False):
"""
Select package and move it accordingly by arguments
:param target_project: project we want to target
:param requests: requests we are working with
:param move: wether to move the requests or not
:param filter_from: filter request list to only those from a specific staging
"""
if self.api.is_adi_project(self.target_project):
no_freeze = True
# If the project is not frozen enough yet freeze it
if not (no_freeze or self.api.prj_frozen_enough(self.target_project)):
print(
'Project needs to be frozen or there was no change for last %d days.'
% MAX_FROZEN_AGE)
print(
'Please freeze the project or use an option to ignore the time from the last freee.'
)
return False
# picks new candidate requests only if it's not to move requests
# ie. the review state of staging-project must be new if newcand is True
newcand = not move
requests = RequestFinder.find_sr(requests,
self.api,
newcand,
consider_stagings=move)
requests_count = len(requests)
for index, request in enumerate(requests, start=1):
print('({}/{}) '.format(index, requests_count), end='')
if not self.select_request(
request, move, filter_from,
remove_exclusion=remove_exclusion):
return False
# Notify everybody about the changes
self.api.update_status_or_deactivate(self.target_project, 'select')
for fprj in self.affected_projects:
self.api.update_status_or_deactivate(fprj, 'select')
return True
def perform(self, packages):
"""
Remove request from staging project
:param packages: packages/requests to delete from staging projects
"""
affected_projects = set()
for request, request_project in RequestFinder.find_staged_sr(packages, self.api).items():
staging_project = request_project["staging"]
affected_projects.add(staging_project)
msg = 'Unselecting "{}" from "{}"'.format(request, staging_project)
print(msg)
self.api.rm_from_prj(staging_project, request_id=request)
self.api.add_review(request, by_group=self.api.cstaging_group, msg="Please recheck")
# Notify everybody about the changes
for prj in affected_projects:
self.api.update_status_comments(prj, "unselect")
def perform(self, packages):
"""
Remove request from staging project
:param packages: packages/requests to delete from staging projects
"""
affected_projects = set()
for request, request_project in RequestFinder.find_staged_sr(packages,
self.api).items():
staging_project = request_project['staging']
affected_projects.add(staging_project)
msg = 'Unselecting "{}" from "{}"'.format(request, staging_project)
print(msg)
self.api.rm_from_prj(staging_project, request_id=request, msg='Removing from {}, re-evaluation needed'.format(staging_project))
self.api.add_review(request, by_group=self.api.cstaging_group, msg='Requesting new staging review')
# Notify everybody about the changes
for prj in affected_projects:
self.api.update_status_comments(prj, 'unselect')
def perform(self, packages):
"""
Remove request from staging project
:param packages: packages/requests to delete from staging projects
"""
affected_projects = set()
for request, request_project in RequestFinder.find_staged_sr(
packages, self.api).items():
staging_project = request_project['staging']
affected_projects.add(staging_project)
msg = 'Unselecting "{}" from "{}"'.format(request, staging_project)
print(msg)
self.api.rm_from_prj(staging_project, request_id=request)
self.api.add_review(request,
by_group=self.api.cstaging_group,
msg='Please recheck')
# Notify everybody about the changes
for prj in affected_projects:
self.api.update_status_comments(prj, 'unselect')
def perform(self, packages, cleanup=False):
"""
Remove request from staging project
:param packages: packages/requests to delete from staging projects
"""
if cleanup:
obsolete = self.api.project_status_requests(
'obsolete', self.filter_obsolete)
if len(obsolete) > 0:
print('Cleanup {} obsolete requests'.format(len(obsolete)))
packages += tuple(obsolete)
ignored_requests = self.api.get_ignored_requests()
affected_projects = set()
for request, request_project in RequestFinder.find_staged_sr(
packages, self.api).items():
staging_project = request_project['staging']
affected_projects.add(staging_project)
msg = 'Unselecting "{}" from "{}"'.format(request, staging_project)
print(msg)
self.api.rm_from_prj(
staging_project,
request_id=request,
msg='Removing from {}, re-evaluation needed'.format(
staging_project))
self.api.add_review(request,
by_group=self.api.cstaging_group,
msg='Requesting new staging review')
req = get_request(self.api.apiurl, str(request))
if req.state.name in (
'new', 'review') and request not in ignored_requests:
print(
' Consider marking the request ignored to let others know not to restage.'
)
# Notify everybody about the changes
for prj in affected_projects:
self.api.update_status_or_deactivate(prj, 'unselect')
def perform(self, requests, cleanup=False):
"""
Unignore a request by removing from ignore list.
"""
requests_ignored = self.api.get_ignored_requests()
length = len(requests_ignored)
if len(requests) == 1 and requests[0] == 'all':
requests_ignored = {}
else:
for request_id in RequestFinder.find_sr(requests, self.api):
if request_id in requests_ignored:
print('{}: unignored'.format(request_id))
del requests_ignored[request_id]
self.comment.add_comment(request_id=str(request_id), comment=self.MESSAGE)
if cleanup:
now = datetime.now()
for request_id in set(requests_ignored):
request = get_request(self.api.apiurl, str(request_id))
if request.state.name not in ('new', 'review'):
changed = dateutil.parser.parse(request.state.when)
diff = now - changed
if diff.days > 3:
print('Removing {} which was {} {} days ago'
.format(request_id, request.state.name, diff.days))
del requests_ignored[request_id]
diff = length - len(requests_ignored)
if diff > 0:
self.api.set_ignored_requests(requests_ignored)
print('Unignored {} requests'.format(diff))
else:
print('No requests to unignore')
return True
def perform(self, requests, move=False,
filter_from=None, no_freeze=False):
"""
Select package and move it accordingly by arguments
:param target_project: project we want to target
:param requests: requests we are working with
:param move: wether to move the requests or not
:param filter_from: filter request list to only those from a specific staging
"""
if self.api.is_adi_project(self.target_project):
no_freeze = True
# If the project is not frozen enough yet freeze it
if not (no_freeze or self.api.prj_frozen_enough(self.target_project)):
print('Project needs to be frozen or there was no change for last %d days.' % MAX_FROZEN_AGE)
print('Please freeze the project or use an option to ignore the time from the last freee.')
return False
# FreezeCommand(self.api).perform(self.target_project)
# picks new candidate requests only if it's not to move requests
# ie. the review state of staging-project must be new if newcand is True
newcand = not move
requests = RequestFinder.find_sr(requests, self.api, newcand)
requests_count = len(requests)
for index, request in enumerate(requests, start=1):
print('({}/{}) '.format(index, requests_count), end='')
if not self.select_request(request, move, filter_from):
return False
# Notify everybody about the changes
self.api.update_status_or_deactivate(self.target_project, 'select')
for fprj in self.affected_projects:
self.api.update_status_or_deactivate(fprj, 'select')
return True
def perform(self, requests, move=False,
from_=None, no_freeze=False):
"""
Select package and move it accordingly by arguments
:param target_project: project we want to target
:param requests: requests we are working with
:param move: wether to move the requests or not
:param from_: location where from move the requests
"""
if self.api.is_adi_project(self.target_project):
no_freeze = True
# If the project is not frozen enough yet freeze it
if not (no_freeze or self.api.prj_frozen_enough(self.target_project)):
print('Freeze the prj first')
return False
# FreezeCommand(self.api).perform(self.target_project)
# picks new candidate requests only if it's not to move requests
# ie. the review state of staging-project must be new if newcand is True
newcand = not move
for request in RequestFinder.find_sr(requests, self.api, newcand):
if not self.select_request(request, move, from_):
return False
# Notify everybody about the changes
self.api.update_status_comments(self.target_project, 'select')
for fprj in self.affected_projects:
self.api.update_status_comments(fprj, 'select')
# now make sure we enable the prj if the prj contains any ringed package
self.api.build_switch_staging_project(self.target_project)
return True
