def makeSnap(self, context): if IBranch.providedBy(context): return self.factory.makeSnap(branch=context) else: if IGitRepository.providedBy(context): [context] = self.factory.makeGitRefs(repository=context) return self.factory.makeSnap(git_ref=context)
def branch_linked(bug, event): """Assign karma to the user who linked the bug to the branch.""" from lp.code.interfaces.branch import IBranch if not IBranch.providedBy(event.other_object): return event.other_object.target.assignKarma(IPerson(event.user), 'bugbranchcreated')
def create(cls, requestor, artifacts=None, grantee=None, pillar=None, information_types=None): """See `IRemoveArtifactSubscriptionsJob`.""" bug_ids = [] branch_ids = [] specification_ids = [] if artifacts: for artifact in artifacts: if IBug.providedBy(artifact): bug_ids.append(artifact.id) elif IBranch.providedBy(artifact): branch_ids.append(artifact.id) elif ISpecification.providedBy(artifact): specification_ids.append(artifact.id) else: raise ValueError("Unsupported artifact: %r" % artifact) information_types = [info_type.value for info_type in information_types or []] metadata = { "bug_ids": bug_ids, "branch_ids": branch_ids, "specification_ids": specification_ids, "information_types": information_types, "requestor.id": requestor.id, } return super(RemoveArtifactSubscriptionsJob, cls).create(pillar, grantee, metadata)
def initial_values(self): distroseries = BuildableDistroSeries.findSeries(self.user) series = [ series for series in distroseries if series.status in (SeriesStatus.CURRENT, SeriesStatus.DEVELOPMENT) ] if IBranch.providedBy(self.context): recipe_text = MINIMAL_RECIPE_TEXT_BZR % self.context.identity elif IGitRepository.providedBy(self.context): default_ref = None if self.context.default_branch is not None: default_ref = self.context.getRefByPath( self.context.default_branch) if default_ref is not None: branch_name = default_ref.name else: branch_name = "ENTER-BRANCH-NAME" recipe_text = MINIMAL_RECIPE_TEXT_GIT % (self.context.identity, branch_name) elif IGitRef.providedBy(self.context): recipe_text = MINIMAL_RECIPE_TEXT_GIT % ( self.context.repository.identity, self.context.name) else: raise AssertionError("Unsupported context: %r" % (self.context, )) return { 'name': self._find_unused_name(self.user), 'recipe_text': recipe_text, 'owner': self.user, 'distroseries': series, 'build_daily': True, 'use_ppa': EXISTING_PPA, }
def __init__(self, name, type, comment, line_number, branch_or_repository, revspec, directory, recipe_data, parent_instruction, source_directory): super(_SourcePackageRecipeDataInstruction, self).__init__() self.name = unicode(name) self.type = type self.comment = comment self.line_number = line_number if IGitRepository.providedBy(branch_or_repository): self.git_repository = branch_or_repository elif IGitRef.providedBy(branch_or_repository): self.git_repository = branch_or_repository if revspec is None: revspec = branch_or_repository.name elif IBranch.providedBy(branch_or_repository): self.branch = branch_or_repository else: raise AssertionError("Unsupported source: %r" % (branch_or_repository, )) if revspec is not None: revspec = unicode(revspec) self.revspec = revspec if directory is not None: directory = unicode(directory) self.directory = directory self.source_directory = source_directory self.recipe_data = recipe_data self.parent_instruction = parent_instruction
def initialize(self): super(BranchRecipeListingView, self).initialize() # Replace our context with a decorated branch, if it is not already # decorated. if (IBranch.providedBy(self.context) and not isinstance(self.context, DecoratedBranch)): self.context = DecoratedBranch(self.context)
def ensure(cls, concrete_artifacts): """See `IAccessArtifactSource`.""" from lp.blueprints.interfaces.specification import ISpecification from lp.bugs.interfaces.bug import IBug from lp.code.interfaces.branch import IBranch existing = list(cls.find(concrete_artifacts)) if len(existing) == len(concrete_artifacts): return existing # Not everything exists. Create missing ones. needed = ( set(concrete_artifacts) - set(abstract.concrete_artifact for abstract in existing)) insert_values = [] for concrete in needed: if IBug.providedBy(concrete): insert_values.append((concrete, None, None)) elif IBranch.providedBy(concrete): insert_values.append((None, concrete, None)) elif ISpecification.providedBy(concrete): insert_values.append((None, None, concrete)) else: raise ValueError("%r is not a supported artifact" % concrete) new = create( (cls.bug, cls.branch, cls.specification), insert_values, get_objects=True) return list(existing) + new
def ensure(cls, concrete_artifacts): """See `IAccessArtifactSource`.""" from lp.blueprints.interfaces.specification import ISpecification from lp.bugs.interfaces.bug import IBug from lp.code.interfaces.branch import IBranch from lp.code.interfaces.gitrepository import IGitRepository existing = list(cls.find(concrete_artifacts)) if len(existing) == len(concrete_artifacts): return existing # Not everything exists. Create missing ones. needed = (set(concrete_artifacts) - set(abstract.concrete_artifact for abstract in existing)) insert_values = [] for concrete in needed: if IBug.providedBy(concrete): insert_values.append((concrete, None, None, None)) elif IBranch.providedBy(concrete): insert_values.append((None, concrete, None, None)) elif IGitRepository.providedBy(concrete): insert_values.append((None, None, concrete, None)) elif ISpecification.providedBy(concrete): insert_values.append((None, None, None, concrete)) else: raise ValueError("%r is not a supported artifact" % concrete) new = create( (cls.bug, cls.branch, cls.gitrepository, cls.specification), insert_values, get_objects=True) return list(existing) + new
def create(cls, requestor, artifacts=None, grantee=None, pillar=None, information_types=None): """See `IRemoveArtifactSubscriptionsJob`.""" bug_ids = [] branch_ids = [] specification_ids = [] if artifacts: for artifact in artifacts: if IBug.providedBy(artifact): bug_ids.append(artifact.id) elif IBranch.providedBy(artifact): branch_ids.append(artifact.id) elif ISpecification.providedBy(artifact): specification_ids.append(artifact.id) else: raise ValueError('Unsupported artifact: %r' % artifact) information_types = [ info_type.value for info_type in information_types or [] ] metadata = { 'bug_ids': bug_ids, 'branch_ids': branch_ids, 'specification_ids': specification_ids, 'information_types': information_types, 'requestor.id': requestor.id } return super(RemoveArtifactSubscriptionsJob, cls).create(pillar, grantee, metadata)
def base(self, value): if IGitRepository.providedBy(value): self.base_git_repository = value self.base_branch = None elif IBranch.providedBy(value): self.base_branch = value self.base_git_repository = None else: raise AssertionError("Unsupported base: %r" % (value, ))
def __init__(self, target=None, *args, **kwargs): if target is not None: assert 'branch' not in kwargs assert 'repository' not in kwargs if IBranch.providedBy(target): kwargs['branch'] = target elif IGitRepository.providedBy(target): kwargs['git_repository'] = target else: raise AssertionError("Unknown code import target %s" % target) super(CodeImport, self).__init__(*args, **kwargs)
def __init__(self, context=None): super(BranchRestrictedOnProductVocabulary, self).__init__(context) if IProduct.providedBy(self.context): self.product = self.context elif IProductSeries.providedBy(self.context): self.product = self.context.product elif IBranch.providedBy(self.context): self.product = self.context.product else: # An unexpected type. raise AssertionError('Unexpected context type')
def _constraintForConcrete(cls, concrete_artifact): from lp.blueprints.interfaces.specification import ISpecification from lp.bugs.interfaces.bug import IBug from lp.code.interfaces.branch import IBranch if IBug.providedBy(concrete_artifact): col = cls.bug elif IBranch.providedBy(concrete_artifact): col = cls.branch elif ISpecification.providedBy(concrete_artifact): col = cls.specification else: raise ValueError("%r is not a valid artifact" % concrete_artifact) return col == concrete_artifact
def findRecipes(branch_or_repository, revspecs=None): """Find recipes for a given branch or repository. :param branch_or_repository: The branch or repository to search for. :param revspecs: If not None, return only recipes whose `revspec` is in this sequence. :return: a collection of `ISourcePackageRecipe`s. """ from lp.code.model.sourcepackagerecipe import SourcePackageRecipe store = Store.of(branch_or_repository) if IGitRepository.providedBy(branch_or_repository): data_clause = (SourcePackageRecipeData.base_git_repository == branch_or_repository) insn_clause = (_SourcePackageRecipeDataInstruction.git_repository == branch_or_repository) elif IBranch.providedBy(branch_or_repository): data_clause = ( SourcePackageRecipeData.base_branch == branch_or_repository) insn_clause = (_SourcePackageRecipeDataInstruction.branch == branch_or_repository) else: raise AssertionError("Unsupported source: %r" % (branch_or_repository, )) if revspecs is not None: concrete_revspecs = [ revspec for revspec in revspecs if revspec is not None ] data_revspec_clause = In(SourcePackageRecipeData.revspec, concrete_revspecs) insn_revspec_clause = In( _SourcePackageRecipeDataInstruction.revspec, concrete_revspecs) if None in revspecs: data_revspec_clause = Or( data_revspec_clause, SourcePackageRecipeData.revspec == None) insn_revspec_clause = Or( insn_revspec_clause, _SourcePackageRecipeDataInstruction.revspec == None) data_clause = And(data_clause, data_revspec_clause) insn_clause = And(insn_clause, insn_revspec_clause) return store.find( SourcePackageRecipe, SourcePackageRecipe.id.is_in( Union( Select(SourcePackageRecipeData.sourcepackage_recipe_id, data_clause), Select( SourcePackageRecipeData.sourcepackage_recipe_id, And( _SourcePackageRecipeDataInstruction.recipe_data_id == SourcePackageRecipeData.id, insn_clause)))))
def __init__(self, existing_proposal): # Circular import. from lp.code.interfaces.branch import IBranch # display_name is the newer style, but IBranch uses the older style. if IBranch.providedBy(existing_proposal.merge_source): display_name = "displayname" else: display_name = "display_name" super(BranchMergeProposalExists, self).__init__( 'There is already a branch merge proposal registered for ' 'branch %s to land on %s that is still active.' % (getattr(existing_proposal.merge_source, display_name), getattr(existing_proposal.merge_target, display_name))) self.existing_proposal = existing_proposal
def _constraintForConcrete(cls, concrete_artifact): from lp.blueprints.interfaces.specification import ISpecification from lp.bugs.interfaces.bug import IBug from lp.code.interfaces.branch import IBranch if IBug.providedBy(concrete_artifact): col = cls.bug elif IBranch.providedBy(concrete_artifact): col = cls.branch elif ISpecification.providedBy(concrete_artifact): col = cls.specification else: raise ValueError( "%r is not a valid artifact" % concrete_artifact) return col == concrete_artifact
def assertBranchImportedOKForCodeImport(self, code_import): """Assert that a branch was pushed into the default branch store.""" if IBranch.providedBy(code_import.target): url = get_default_bazaar_branch_store()._getMirrorURL( code_import.branch.id) branch = Branch.open(url) commit_count = branch.revno() else: repo_path = os.path.join(self.target_store, code_import.target.unique_name) commit_count = int( subprocess.check_output(["git", "rev-list", "--count", "HEAD"], cwd=repo_path, universal_newlines=True)) self.assertEqual(self.foreign_commit_count, commit_count)
def _getHeaders(self, email, recipient): headers = BaseMailer._getHeaders(self, email, recipient) reason, rationale = self._recipients.getReason(email) headers['X-Launchpad-Branch'] = reason.branch.unique_name if IGitRef.providedBy(reason.branch): if IProduct.providedBy(reason.branch.target): headers['X-Launchpad-Project'] = reason.branch.target.name elif IBranch.providedBy(reason.branch): if reason.branch.product is not None: headers['X-Launchpad-Project'] = reason.branch.product.name if self.revno is not None: headers['X-Launchpad-Branch-Revision-Number'] = str(self.revno) if self.revision_id is not None: headers['X-Launchpad-Branch-Revision-ID'] = self.revision_id return headers
def _recipe_names(self): """A generator of recipe names.""" # +junk-daily doesn't make a very good recipe name, so use the # branch name in that case; similarly for personal Git repositories. if ((IBranch.providedBy(self.context) and self.context.target.allow_recipe_name_from_target) or ((IGitRepository.providedBy(self.context) or IGitRef.providedBy(self.context)) and self.context.namespace.allow_recipe_name_from_target)): branch_target_name = self.context.target.name.split('/')[-1] else: branch_target_name = self.context.name yield "%s-daily" % branch_target_name counter = itertools.count(1) while True: yield "%s-daily-%s" % (branch_target_name, counter.next())
def getStartedJobForImport(self, code_import): """Get a started `CodeImportJob` for `code_import`. This method approves the import, creates a job, marks it started and returns the job. It also makes sure there are no branches or foreign trees in the default stores to interfere with processing this job. """ if code_import.review_status != CodeImportReviewStatus.REVIEWED: code_import.updateFromData( {'review_status': CodeImportReviewStatus.REVIEWED}, self.factory.makePerson()) job = getUtility(ICodeImportJobSet).getJobForMachine('machine', 10) self.assertEqual(code_import, job.code_import) source_details = CodeImportSourceDetails.fromArguments( removeSecurityProxy(job.makeWorkerArguments())) if IBranch.providedBy(code_import.target): clean_up_default_stores_for_import(source_details) self.addCleanup(clean_up_default_stores_for_import, source_details) return job
def related_package_branch_info(self): branch_to_check = self.getBranch() if IBranch.providedBy(branch_to_check): branch_target = IBranchTarget(branch_to_check.target) return branch_target.getRelatedPackageBranchInfo(branch_to_check, limit_results=5)
def makeSnap(self, context): if IBranch.providedBy(context): return self.factory.makeSnap(branch=context) else: return self.factory.makeSnap(git_ref=context)