def updateFromData(self, data, user):
"""See `ICodeImport`."""
event_set = getUtility(ICodeImportEventSet)
new_whiteboard = None
if 'whiteboard' in data:
whiteboard = data.pop('whiteboard')
if whiteboard != self.branch.whiteboard:
if whiteboard is None:
new_whiteboard = ''
else:
new_whiteboard = whiteboard
self.branch.whiteboard = whiteboard
token = event_set.beginModify(self)
for name, value in data.items():
setattr(self, name, value)
if 'review_status' in data:
if data['review_status'] == CodeImportReviewStatus.REVIEWED:
if self.import_job is None:
CodeImportJobWorkflow().newJob(self)
else:
self._removeJob()
event = event_set.newModify(self, user, token)
if event is not None or new_whiteboard is not None:
code_import_updated(self, event, new_whiteboard, user)
return event
def make_running_import(code_import=None,
machine=None,
date_started=None,
factory=None,
logtail=None):
"""Return a code import with a running job.
:param code_import: The code import to create the job for. If None, an
anonymous CodeImport is created.
:param machine: The `CodeImportMachine` to associate with the running
job. If None, an anonymous CodeImportMachine is created.
:param date_started: If specified this overrides the UTC_NOW timestamp
of the newly started job.
:param factory: The LaunchpadObjectFactory to use for the creation of
the objects. If None, one is created.
:param logtail: An optional string to put in the logtail field of the job.
"""
if factory is None:
factory = LaunchpadObjectFactory()
if code_import is None:
code_import = factory.makeCodeImport()
if machine is None:
machine = factory.makeCodeImportMachine(set_online=True)
# The code import must be in a reviewed state.
if code_import.review_status != CodeImportReviewStatus.REVIEWED:
code_import.updateFromData(
{'review_status': CodeImportReviewStatus.REVIEWED},
code_import.registrant)
CodeImportJobWorkflow().startJob(code_import.import_job, machine)
if logtail:
CodeImportJobWorkflow().updateHeartbeat(code_import.import_job,
logtail)
assert code_import.import_job.state == CodeImportJobState.RUNNING
if date_started is not None:
# Override the job date_started.
naked_job = removeSecurityProxy(code_import.import_job)
naked_job.date_started = date_started
return code_import
def make_finished_import(code_import=None,
status=None,
date_finished=None,
factory=None):
"""Return a code import with a new finished job.
:param code_import: The code import to create the job for. If None, an
anonymous CodeImport is created.
:param status: The result status. If not specified it is set to
SUCCESSFUL.
:param date_finished: If specified this overrides the date_last_successful
attribute of the code_import if the state is SUCCESSFUL.
:param factory: The LaunchpadObjectFactory to use for the creation of
the objects. If None, one is created.
"""
if factory is None:
factory = LaunchpadObjectFactory()
if code_import is None:
code_import = factory.makeCodeImport()
if status is None:
status = CodeImportResultStatus.SUCCESS
# The code import must be in a reviewed state.
if code_import.review_status != CodeImportReviewStatus.REVIEWED:
code_import.updateFromData(
{'review_status': CodeImportReviewStatus.REVIEWED},
code_import.registrant)
# If the job isn't running, make it run.
if code_import.import_job.state != CodeImportJobState.RUNNING:
machine = factory.makeCodeImportMachine(set_online=True)
CodeImportJobWorkflow().startJob(code_import.import_job, machine)
CodeImportJobWorkflow().finishJob(code_import.import_job, status, None)
if date_finished is not None and status == CodeImportResultStatus.SUCCESS:
# Override the code import date last successful.
naked_import = removeSecurityProxy(code_import)
naked_import.date_last_successful = date_finished
return code_import
def new(self, registrant, target, branch_name, rcs_type,
url=None, cvs_root=None, cvs_module=None, review_status=None,
owner=None):
"""See `ICodeImportSet`."""
if rcs_type == RevisionControlSystems.CVS:
assert cvs_root is not None and cvs_module is not None
assert url is None
elif rcs_type in NON_CVS_RCS_TYPES:
assert cvs_root is None and cvs_module is None
assert url is not None
else:
raise AssertionError(
"Don't know how to sanity check source details for unknown "
"rcs_type %s" % rcs_type)
if review_status is None:
# Auto approve imports.
review_status = CodeImportReviewStatus.REVIEWED
if not target.supports_code_imports:
raise AssertionError("%r doesn't support code imports" % target)
if owner is None:
owner = registrant
# Create the branch for the CodeImport.
namespace = target.getNamespace(owner)
import_branch = namespace.createBranch(
branch_type=BranchType.IMPORTED, name=branch_name,
registrant=registrant)
code_import = CodeImport(
registrant=registrant, owner=owner, branch=import_branch,
rcs_type=rcs_type, url=url,
cvs_root=cvs_root, cvs_module=cvs_module,
review_status=review_status)
getUtility(ICodeImportEventSet).newCreate(code_import, registrant)
notify(ObjectCreatedEvent(code_import))
# If created in the reviewed state, create a job.
if review_status == CodeImportReviewStatus.REVIEWED:
CodeImportJobWorkflow().newJob(code_import)
return code_import
def _removeJob(self):
"""If there is a pending job, remove it."""
job = self.import_job
if job is not None:
if job.state == CodeImportJobState.PENDING:
CodeImportJobWorkflow().deletePendingJob(self)
def new(self,
registrant,
context,
branch_name,
rcs_type,
target_rcs_type,
url=None,
cvs_root=None,
cvs_module=None,
review_status=None,
owner=None):
"""See `ICodeImportSet`."""
if rcs_type == RevisionControlSystems.CVS:
assert cvs_root is not None and cvs_module is not None
assert url is None
elif rcs_type in NON_CVS_RCS_TYPES:
assert cvs_root is None and cvs_module is None
assert url is not None
else:
raise AssertionError(
"Don't know how to sanity check source details for unknown "
"rcs_type %s" % rcs_type)
if owner is None:
owner = registrant
if target_rcs_type == TargetRevisionControlSystems.BZR:
# XXX cjwatson 2016-10-15: Testing
# IHasBranches.providedBy(context) would seem more in line with
# the Git case, but for some reason ProductSeries doesn't
# provide that. We should sync this up somehow.
try:
target = IBranchTarget(context)
except TypeError:
raise CodeImportInvalidTargetType(context, target_rcs_type)
namespace = target.getNamespace(owner)
elif target_rcs_type == TargetRevisionControlSystems.GIT:
if not IHasGitRepositories.providedBy(context):
raise CodeImportInvalidTargetType(context, target_rcs_type)
if rcs_type != RevisionControlSystems.GIT:
raise AssertionError(
"Can't import rcs_type %s into a Git repository" %
rcs_type)
target = namespace = get_git_namespace(context, owner)
else:
raise AssertionError("Can't import to target_rcs_type %s" %
target_rcs_type)
if review_status is None:
# Auto approve imports.
review_status = CodeImportReviewStatus.REVIEWED
if not target.supports_code_imports:
raise AssertionError("%r doesn't support code imports" % target)
# Create the branch for the CodeImport.
if target_rcs_type == TargetRevisionControlSystems.BZR:
import_target = namespace.createBranch(
branch_type=BranchType.IMPORTED,
name=branch_name,
registrant=registrant)
else:
import_target = namespace.createRepository(
repository_type=GitRepositoryType.IMPORTED,
name=branch_name,
registrant=registrant)
hosting_path = import_target.getInternalPath()
getUtility(IGitHostingClient).create(hosting_path)
code_import = CodeImport(registrant=registrant,
owner=owner,
target=import_target,
rcs_type=rcs_type,
url=url,
cvs_root=cvs_root,
cvs_module=cvs_module,
review_status=review_status)
getUtility(ICodeImportEventSet).newCreate(code_import, registrant)
notify(ObjectCreatedEvent(code_import))
# If created in the reviewed state, create a job.
if review_status == CodeImportReviewStatus.REVIEWED:
CodeImportJobWorkflow().newJob(code_import)
return code_import