~ursinha/lp-qa-tools/bzr-tarmacland

# Copyright (C) 2005, 2006, 2007 by Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""Submit an email to a Patch Queue Manager"""

from bzrlib import (

    config as _mod_config,

    errors,

    gpg,

    osutils,

    urlutils,

    )

from bzrlib.branch import Branch

from bzrlib.email_message import EmailMessage

from bzrlib.smtp_connection import SMTPConnection

from bzrlib.trace import note, warning

class BadCommitMessage(errors.BzrError):

    _fmt = "The commit message %(msg)r cannot be used by pqm."

    def __init__(self, message):

        errors.BzrError.__init__(self)

        self.msg = message

class PQMSubmission(object):

    """A request to perform a PQM merge into a branch."""

    def __init__(self, source_branch, public_location=None,

                 submit_location=None, message=None):

        """Create a PQMSubmission object.

        :param source_branch: the source branch for the merge

        :param public_location: the public location of the source branch

        :param submit_location: the location of the target branch

        :param message: The message to use when committing this merge

        If any of public_location, submit_location or message are

        omitted, they will be calculated from source_branch.

        """

        if source_branch is None:

            raise errors.NoMergeSource()

        self.source_branch = source_branch

        if public_location is None:

            public_location = self.source_branch.get_public_branch()

            # Fall back to the old public_repository hack.

            if public_location is None:

                src_loc = source_branch.bzrdir.root_transport.local_abspath('.')

                repository = source_branch.repository

                repo_loc = repository.bzrdir.root_transport.local_abspath('.')

                repo_config = _mod_config.LocationConfig(repo_loc)

                public_repo = repo_config.get_user_option("public_repository")

                if public_repo is not None:

                    warning("Please use public_branch, not public_repository, "

                            "to set the public location of branches.")

                    branch_relpath = osutils.relpath(repo_loc, src_loc)

                    public_location = urlutils.join(public_repo, branch_relpath)

            if public_location is None:

                raise errors.BzrCommandError(

                    'No public branch location given.  Please specify with '

                    '--public-location or see "bzr help pqm-submit" to see how '

                    'to set it in ~/.bazaar/locations.conf')

        self.public_location = public_location

        if submit_location is None:

            config = self.source_branch.get_config()

            # First check the deprecated pqm_branch config key:

            submit_location = config.get_user_option('pqm_branch')

            if submit_location is not None:

                warning("Please use submit_branch, not pqm_branch to set "

                        "the PQM merge target branch.")

            else:

                # Otherwise, use the standard config key:

                submit_location = self.source_branch.get_submit_branch()

            if submit_location is None:

                raise errors.NoSubmitBranch(self.source_branch)

        self.submit_location = submit_location

        # Check that the message is okay to pass to PQM

        if message is None:

            repository = self.source_branch.repository

            rev = repository.get_revision(self.source_branch.last_revision())

            message = rev.message

        self.message = message.encode('utf8')

        if '\n' in self.message:

            raise BadCommitMessage(self.message)

    def check_public_branch(self):

        """Check that the public branch is up to date with the local copy."""

        note('Checking that the public branch is up to date ...')

        local_revision = self.source_branch.last_revision()

        public_revision = Branch.open(self.public_location).last_revision()

        if local_revision != public_revision:

            raise errors.PublicBranchOutOfDate(

                self.public_location, local_revision)

    def to_lines(self):

        """Serialise as a list of lines."""

        return ['star-merge %s %s\n' % (self.public_location, self.submit_location)]

    def to_signed(self):

        """Serialize as a signed string."""

        unsigned_text = ''.join(self.to_lines())

        unsigned_text = unsigned_text.encode('ascii') #URLs should be ascii

        strategy = gpg.GPGStrategy(self.source_branch.get_config())

        return strategy.sign(unsigned_text)

    def to_email(self, mail_from, mail_to, sign=True):

        """Serialize as an email message.

        :param mail_from: The from address for the message

        :param mail_to: The address to send the message to

        :param sign: If True, gpg-sign the email

        :return: an email message

        """

        if sign:

            body = self.to_signed()

        else:

            body = ''.join(self.to_lines())

        message = EmailMessage(mail_from, mail_to, self.message, body)

        return message

def submit(branch, message, dry_run=False, public_location=None):

    """Submit the given branch to the pqm."""

    config = branch.get_config()

    submission = PQMSubmission(

        source_branch=branch, public_location=public_location, message=message)

    mail_from = config.get_user_option('pqm_user_email')

    if not mail_from:

        mail_from = config.username()

    mail_from = mail_from.encode('utf8') # Make sure this isn't unicode

    mail_to = config.get_user_option('pqm_email')

    if not mail_to:

        raise errors.BzrCommandError('No PQM submission address specified '

                                     'in configuration')

    mail_to = mail_to.encode('utf8') # same here

    submission.check_public_branch()

    message = submission.to_email(mail_from, mail_to)

    if dry_run:

        print message.as_string()

        return

    SMTPConnection(config).send_email(message)