Merge lp:~oddbloke/pqm/remove-vcs-abstraction into lp:pqm

[Jelmer Vernooij]

Unmerged revisions

201. By Dan Watkins on 2008-07-04

Merged in further test changes.

200. By Dan Watkins on 2008-07-04

Renamed Bazaar2Handler to BzrHandler.

199. By Dan Watkins on 2008-07-04

Removed VCSHandler.

198. By Dan Watkins on 2008-07-02

Moved Command.wrap_command to MergeCommand.wrap_command.

197. By Dan Watkins on 2008-07-02

Removed needless merge_method parameter to MergeCommand.do_merge.

196. By Dan Watkins on 2008-07-02

Moved Command.do_merge to MergeCommand.do_merge.

195. By Dan Watkins on 2008-07-02

Removed debug statement from test.

194. By Dan Watkins on 2008-07-02

Removed now-irrelevant config filenames.

193. By Dan Watkins on 2008-07-02

Removed Command.get_vcs.

192. By Dan Watkins on 2008-07-02

Removed Command.get_branch_handler and accompanying tests.

=== modified file 'pqm/__init__.py'
--- pqm/__init__.py	2010-04-20 12:11:40 +0000
+++ pqm/__init__.py	2010-05-04 17:12:27 +0000
@@ -56,7 +56,218 @@
         sys.exit(1)
 
 
+<<<<<<< TREE
 def verify_sig(sender, msg, sig, check_replay, logger, keyring):
+=======
+if 'PQM_CONFIG' in os.environ:
+    configfile_names = [os.environ['PQM_CONFIG']]
+else:
+    configfile_names = ['/etc/pqm.conf']
+    configfile_names.append(os.path.expanduser('~/.pqm.conf'))
+
+
+class Script(object):
+    """A command script."""
+
+    whitespace_re = re.compile('^\s*$')
+    pgp_re = re.compile('^-----BEGIN PGP.*MESSAGE')
+    pgp_end_re = re.compile('^-----BEGIN PGP SIG')
+    # parser for merge recognition
+    star_re = re.compile('^star-merge (\S+/\S+)\s+(\S+/\S+)\s*$')
+    # parse matcher for the debug command
+    debug_re = re.compile('^debug')
+
+    def __init__(self, filename, logger, verify_sigs, submission_time,
+                 branch_spec_handler, configp):
+        """Create a script for a given file."""
+        self.debug = True
+        self.filename = filename
+        self.logger = logger
+        self.verify_sigs = verify_sigs
+        self.readComplete = False
+        self.submission_time = submission_time
+        self._branch_spec_handler = branch_spec_handler
+        self._configp = configp
+
+    def _read(self):
+        """Read in the script details."""
+        #  This is cruft from the binary script. It actually does need
+        #  to read the file twice with the current layering - yes thats funky, but
+        #  not something I plan on breaking in an ad hoc manner right now. The
+        #  read_email and email.message_from_file and verify_sig functions need
+        #  rearranging and consolidating to allow this.
+        details = read_email(self.logger, open(self.filename))
+        (self.sender, self.subject, self.msg, self.sig) = details
+        self.signing_email = None
+        if self.verify_sigs:
+            sigid,siguid = verify_sig(self.sender,
+                                      self.msg,
+                                      self.sig, 
+                                      0,
+                                      self.logger)
+            self.signing_email = siguid
+        self.msg = email.message_from_file(open(self.filename))
+        self.sender = self.msg['From']
+        self.logger.info ('sender: %s' , self.sender)
+        self.logger.info ('subject: %s' , self.subject)
+        self.readComplete = True
+
+    def getProjects(self):
+        """Return the set of projects this script will affect."""
+        result = set()
+        for command in self.getCommands():
+            result.update(command.getProjects())
+        return result
+
+    def getSender(self):
+        """Get the sender of the script."""
+        if not self.readComplete:
+            self._read()
+        return self.sender
+
+    def getSubject(self):
+        """Get the subject of the script."""
+        if not self.readComplete:
+            self._read()
+        return self.subject
+
+    def getContent(self):
+        """Get the raw content for folk that want it."""
+        if not self.readComplete:
+            self._read()
+        return self.msg.get_payload()
+
+    def getLines(self):
+        """Get the lines in the script."""
+        if not self.readComplete:
+            self._read()
+        to_skip = 0
+        result = []
+        for line in self.msg.get_payload().split('\n'):
+            if to_skip:
+                to_skip -= 1
+                continue
+            if self.whitespace_re.match(line):
+                continue
+            if self.pgp_re.match(line):
+                to_skip = 2
+                continue
+            if self.pgp_end_re.match(line):
+                break
+            result.append(line)
+        return result
+
+    def getCommands(self):
+        """Get the actual command lines from the script."""
+        logger.info("parsing commands")
+        result = []
+        legacy_lines = []
+        for line in self.getLines():
+            if not self.isCommand(line):
+                continue
+            # identify and construct commands
+            star_match = Script.star_re.match(line)
+            debug_match = Script.debug_re.match(line)
+            if star_match:
+                result.append(MergeCommand(self,
+                                           self._branch_spec_handler,
+                                           self._configp,
+                                           star_match.group(1),
+                                           star_match.group(2)))
+            elif debug_match:
+                result.append(DebugCommand(self,
+                                           self._branch_spec_handler,
+                                           self._configp))
+        return result
+
+    def getSubmissionTime(self):
+        """Return the time the script was submitted."""
+        return self.submission_time
+
+    def isCommand(self, line):
+        """Return true if line looks like a valid command line."""
+        # XXX: This is not ready yet, its still in CommandRunners guts.
+        return True
+
+    def run(self):
+        """Run this script.
+
+        :return: (successes, unrecognized, output)
+        """
+        successes = []
+        unrecognized = []
+        output = []
+        for command in self.getCommands():
+            command_result = command.run()
+            successes.extend(command_result[0])
+            unrecognized.extend(command_result[1])
+            output.extend(command_result[2])
+        return successes, unrecognized, output
+
+
+def find_patches(queuedir, logger, verify_sigs, branch_spec_handler, configp):
+    patches=[]
+    patches_re=re.compile('^patch\.\d+$')
+    for f in os.listdir(queuedir):
+        if patches_re.match(f):
+            fname=os.path.join(queuedir, f)
+            submission_time = os.stat(fname)[stat.ST_MTIME]
+            patches.append((Script(fname, logger, verify_sigs, 
+                                   submission_time, branch_spec_handler,
+                                   configp), 
+                            f))
+    def sortpatches(a, b):
+        return cmp(a[1], b[1])
+    patches.sort(sortpatches)
+    return [patch[0] for patch in patches]
+ 
+def read_email(logger, file=None):
+    """Read an email and check it has the required structure for commands."""
+    if not file:
+        file = sys.stdin
+    msg = email.message_from_file(file)
+    sender = msg['From']
+    logger.info("recieved email from %s", sender)
+    subject = msg['Subject']
+    if not sender:
+        raise PQMException(None, "No From specified")
+    if (not subject) or subject=='':
+        raise PQMException(sender, "No Subject specified")
+    text = None
+    sig = None
+    if msg.is_multipart():
+        print ("Multipart support is known buggy. Patches, or better still"
+               "unittest tests with or without patches solicited.")
+        parts = msg.get_payload()
+        if not len(parts) == 2:
+            raise PQMException(sender, 
+                        "Multipart message must have exactly two parts")
+        if not parts[0].get_content_type() == 'text/plain':
+            raise PQMException(sender,
+                        "First part of multipart message must be text/plain")
+        if not parts[1].get_content_type() == 'application/pgp-signature':
+            raise PQMException(sender, 
+                        "Second part of multipart message must be"
+                        " application/pgp-signature")
+        return (sender, 
+                subject,
+                parts[0].get_payload(),
+                parts[1].get_payload())
+    else:
+        return (sender, subject, msg.get_payload(), None)
+
+
+class PQMException(Exception):
+    """PWM specific exceptions derive from this class."""
+    def __init__(self, sender, msg):
+        self.sender = sender
+        self.msg = msg
+
+    def __str__(self):
+        return `self.msg`
+
+def verify_sig(sender, msg, sig, check_replay, logger):
+>>>>>>> MERGE-SOURCE
     """Verify the GPG signature on a message."""
     verifier = GPGSigVerifier([keyring], gpgv=gpgv_path)
     try:
@@ -152,6 +363,469 @@
         return output
 
 
+<<<<<<< TREE
+=======
+class Command(object):
+    """A single command in a script.
+
+    These are generated by the parser for specific messages - such as Script
+    for the original format pqm messages.
+    """
+
+    def __init__(self, script, branch_spec_handler, configp):
+        """Construct a command.
+
+        :param script: The Script object with user details etc for this command.
+        :param branch_spec_handler: The branch specification handler for this
+                                    PQM.
+        :param configp: The ConfigParser for this PQM.
+        """
+        self.script = script
+        self.branch_spec_handler = branch_spec_handler
+        self.configp = configp
+        self._url_override_mapper = None
+        self.successful = []
+        self._vcs = BzrHandler()
+
+    def asHTML(self):
+        """Return an HTML representation of the command."""
+        raise NotImplementedError(self.asHTML)
+
+    def __eq__(self, other):
+        # command top level objects have no intrinsic state.
+        return isinstance(other, Command)
+
+    def getBranchConfig(self, branch_spec):
+        return self.branch_spec_handler.get_target_config(branch_spec)
+        
+    def getProjects(self):
+        """Return the projects this Command will affect."""
+        raise NotImplementedError(self.getProjects)
+
+    def log_with_status(self, logger, message, *args):
+        """Log message to the logfile, and to the status file."""
+        logger.info(message, *args)
+        self.branch_spec_handler.status.line(message % args)
+
+    def _branch_name(self, branchspec):
+        elements = branchspec.split('/')
+        return elements[-1]
+
+    def branch_from_config(self, config, sender, branch_list, fullpath):
+        """build the config config in dir fullpath. Then
+        find one of branch_list in the config, and
+        return the path to it."""
+        # TODO: probe the config path for the url to get -
+        # config package isn't guaranteed arch-style.
+        config_segments = config.split('/')
+        config_path = config_segments.pop()
+        done = False
+        while not done:
+            try:
+                config_branch = '/'.join(config_segments)
+                self._vcs.make_local_dir(sender, config_branch, fullpath)
+                done = True
+            except PQMTlaFailure, e:
+                if config_path == config or len(config_segments) == 1:
+                    raise
+                config_path = '/'.join((config_segments.pop(), config_path))
+                if os.path.exists(fullpath):
+                    shutil.rmtree(fullpath)
+        try:
+            stream = urllib.urlopen(os.path.join(fullpath, config_path))
+        except IOError,e:
+            if e.errno == errno.ENOENT:
+                raise PQMException(sender, "No such config '%s'" % config_path)
+            else:
+                raise PQMException(sender, "IOError opening configuration '%s'" % config_path)
+        cm_config = config_manager.Config(fromStream=stream,
+            override_mapper=self._get_url_override_mapper())
+        cm_config.build(fullpath)
+        if config_branch in branch_list:
+            return fullpath
+        for path, entry in cm_config.get_entries().items():
+            # probably want a url comparison that understands url parameters
+            # TODO: but that can wait.
+            if (entry.url in branch_list or 
+                (entry.url.startswith('arch://') and
+                 entry.url[7:] in branch_list)):
+                return os.path.join(fullpath, path)
+        raise PQMException(sender,
+                           "Branch %s not found in config" % branch)
+    
+    def check_commit_regex(self, branch, config):
+        """Confirm that commit message matches any regexp supplied in the
+        configuration file.
+        """
+        if not config["commit_re"]:
+            # No regexp, therefore accept anything
+            return
+        regex = config["commit_re"]
+        if re.match(regex, self.commitmsg):
+            # Regexp matched, accept the commitmsg
+            return
+        raise PQMException(self.script.getSender(),
+                           "Commit message [%s] does not match commit_re [%s]"
+                           % (self.commitmsg, regex)
+                           )
+
+    def check_target(self, branch, line):
+        """Check that the sender is allowed to commit to torepo/to_revision"""
+        # FIXME check gpg etc etc.
+        try:
+            self.getBranchConfig(branch)
+        except KeyError:
+            raise PQMCmdFailure(self.script.getSender(),
+                                self.successful,
+                                line,
+                                ["Sender not authorised to commit to branch %s"
+                                    % branch])
+
+    def cleanup_wd(self):
+        """Cleans up all possible working dirs."""
+        self.log_with_status(logger, "cleaning working directory")
+        for top in os.listdir(workdir):
+            self.rm_rf(os.path.join(workdir, top))
+        for branch, value in self.branch_spec_handler._specs.items():
+            possible_dir = value['build_dir']
+            if not possible_dir:
+                continue
+            if not os.path.exists(possible_dir):
+                continue
+            for top in os.listdir(possible_dir):
+                self.rm_rf(os.path.join(possible_dir, top))
+
+    def _make_wd_path(self, directory, branch):
+        """Make the path to be used for branch in directory"""
+        elements = branch.split('/')
+        index = 0
+        if elements[0] == '':
+            index = 1
+        result = os.path.join(directory, elements[index])
+        if result[-1] == ':':
+            result = result[:-1]
+        return result
+        
+    def prep_wd(self, sender, dirpath, branch, config):
+        branch_name = self._branch_name(branch)
+        if not os.access(dirpath, os.W_OK):
+            os.mkdir(dirpath)
+        # set revision to the last element of the branch...
+        if config:
+            elements=re.split("/", config)
+            fullpath=os.path.join(dirpath, "%s---%s" % (elements[0], branch_name))
+        else:
+            fullpath=os.path.join(dirpath, branch_name)        
+    
+        if os.access(fullpath, os.W_OK):
+            logger.error("Working dir already exists: " + fullpath)
+            raise PQMException(sender, "Working dir already exists: " + fullpath)
+        return fullpath
+    
+    def _get_url_override_mapper(self):
+        """Get a URL override mapper from the config."""
+        if self._url_override_mapper is not None:
+            return self._url_override_mapper
+        mapper = config_manager.URLMapper()
+        if not self.configp.has_section('location overrides'):
+            return mapper
+        for target, source in self.configp.section_items('location overrides'):
+            equal_pos = source.find('=')
+            if (equal_pos > -1 and target.find('//') == -1 and
+                source.startswith('//')):
+                # : triggers separation, THANKS config-parser.
+                target = target + ":" + source[:equal_pos]
+                source = source[equal_pos + 1:]
+                print target, source
+            mapper.add_map(source, target)
+        self._url_override_mapper = mapper
+        return mapper
+
+    def validate_revision(self, branch):
+        if not self._vcs.branch_exists(self.script.getSender(), branch):
+            raise PQMCmdFailure(self.script.getSender(),
+                                self.successful,
+                                line,
+                                self.output + self._vcs.last_error.output)
+
+    def rm_rf(self, top):
+        os.chmod(top, 0755)
+        for root, dirs, files in os.walk(top, topdown=True):
+            for name in files:
+                if not os.path.islink(os.path.join(root, name)):
+                    os.chmod(os.path.join(root, name), 0644)
+            for name in dirs:
+                if not os.path.islink(os.path.join(root, name)):
+                    os.chmod(os.path.join(root, name), 0755)
+
+        for root, dirs, files in os.walk(top, topdown=False):
+            for name in files:
+                os.remove(os.path.join(root, name))
+            for name in dirs:
+                if os.path.islink(os.path.join(root, name)):
+                    os.remove(os.path.join(root, name))
+                else:
+                    os.rmdir(os.path.join(root, name))
+    
+    def run(self):
+        """Run this script.
+
+        :return: (successes, unrecognized, output)
+        """
+        # current prelude code useful to all commands
+        # may need to shrink or grow in the future.
+        self.successful = []
+        self.unrecognized = []
+        self.output = []
+        self.commitmsg = self.script.getSubject()
+        self.user_email = self.script.signing_email
+        self.sender = self.script.getSender()
+
+    def run_in_dir(self, local_dir, method, *args):
+        """call method after chdiring to local_dir, then chdir back."""
+        orig_dir = os.getcwdu()
+        try:
+            os.chdir(local_dir)
+            return method(*args)
+        finally:
+            os.chdir(orig_dir)
+
+    def run_precommit(self, branch, config, line, dir):
+        command = PrecommitCommand(
+            self.script,
+            self.branch_spec_handler,
+            self.configp,
+            config,
+            line,
+            dir)
+        successes, unrecognized, command_output = command.run()
+        self.successful.extend(successes)
+        self.unrecognized.extend(unrecognized)
+        self.output.extend(command_output)
+
+
+class DebugCommand(Command):
+    """Turns on debug mode."""
+
+    def asHTML(self):
+        return "debug"
+
+    def getProjects(self):
+        """Debug applies to no projects."""
+        return set()
+        
+    def run(self):
+        """Turn debug mode on."""
+        super(DebugCommand, self).run()
+        self.script.debug = True
+        return ['debug'], [], ['Debug mode enabled.']
+
+
+class MergeCommand(Command):
+    """A merge request."""
+
+    def __init__(self, script, branch_spec_handler, configp, from_branch, to_branch):
+        """Construct a merge command.
+
+        :param from_branch: The branch specification to merge from.
+        :param to_branch: The branch specification to merge into.
+        """
+        super(MergeCommand, self).__init__(script, branch_spec_handler, configp)
+        self.from_branch = from_branch
+        self.to_branch = to_branch
+
+    def asHTML(self):
+        return cgi.escape("Merge %s %s" % (self.from_branch, self.to_branch))
+
+    def __eq__(self, other):
+        return (super(MergeCommand, self).__eq__(other) and
+                isinstance(other, MergeCommand) and
+                self.from_branch == other.from_branch and
+                self.to_branch == other.to_branch)
+
+    def getProjects(self):
+        b, config = self.getBranchConfig(self.to_branch)
+        project = config['project']
+        if project is not None:
+            return set([project])
+        else:
+            return set()
+
+    def wrap_command(self, command, line, sender, *args):
+        try:
+            self.output += command(sender, *args)
+        except PQMTlaFailure, e:
+            raise PQMCmdFailure(sender, self.successful, line, self.output + e.output)
+
+    def do_merge(self, from_repo_revision, to_repo_revision, merge_name, line):
+        sender = self.script.getSender()
+        # Star-merge
+        self.check_target(to_repo_revision, line)
+        to_repo_revision, config = self.getBranchConfig(to_repo_revision)
+        self.validate_revision(from_repo_revision)
+        self.validate_revision(to_repo_revision)
+        self.check_commit_regex(to_repo_revision, config)
+        logger.info("current cwd is %s", os.getcwd())
+        logger.info("getting working dir for %s", to_repo_revision)
+        dir = self.get_wd(sender, to_repo_revision, config)
+        origdir = os.getcwd()
+        merge_line = 'Executing %s %s at %s' % (merge_name,
+                                                from_repo_revision,
+                                                time.strftime('%c'))
+        self.log_with_status(logger, merge_line)
+        self.output += [
+            '\n',
+            merge_line,
+            '\n',
+            ]
+        self.wrap_command(self._vcs.do_star_merge, line, sender,
+                          from_repo_revision, dir)
+        self.run_precommit(to_repo_revision, config, line, dir)
+        os.chdir(origdir)
+        self.log_with_status(logger, "success: %s", line)
+        self.successful.append(line)
+        self.output += ['\n', '%s succeeded at %s' % (merge_name, time.strftime('%c')), '\n']
+        self._vcs.commit(sender, dir, self.commitmsg, to_repo_revision, config)
+
+    def get_wd(self, sender, branch, config):
+        dirpath = self._make_wd_path(workdir, branch)
+        commiters = config['commiters']
+        if commiters and not self.user_email in groups[commiters]:
+            logger.error("%s is not permitted to commit to %s", 
+                         self.user_email,
+                         branch)
+            raise PQMException(sender,
+                               "%s is not permitted to commit to %s" % (
+                                    self.user_email, branch))
+        possible_dir = config['build_dir']
+        if possible_dir:
+            dirpath = self._make_wd_path(possible_dir, branch)
+        build_config = config['build_config']
+        fullpath = self.prep_wd(sender, dirpath, branch, build_config)
+        if build_config:
+            branch_list = [branch]
+            if config.get('published_at', None):
+                branch_list.append(config['published_at'])
+            return self.branch_from_config(build_config, sender, branch_list, fullpath)
+        else:
+            self._vcs.make_local_dir(sender, branch, fullpath)
+            return fullpath
+
+    def run(self):
+        super(MergeCommand, self).run()
+        self.cleanup_wd()
+        self.do_merge(from_repo_revision=self.from_branch,
+                      to_repo_revision=self.to_branch,
+                      merge_name='star-merge',
+                      line='merge %s %s' % (self.from_branch, self.to_branch))
+        return self.successful, self.unrecognized, self.output
+
+
+class PrecommitCommand(Command):
+    """A pre-commit command."""
+
+    def __init__(self, script, branch_spec_handler, configp, config, line, dir):
+        """Construct a merge command.
+
+        :param config: The branch config to use for the precommit logic.
+        :param line: The parsed line(s) that triggered the precommit hook.
+        :param dir: The directory to run the precommit check in.
+        """
+        super(PrecommitCommand, self).__init__(script, branch_spec_handler, configp)
+        self.config = config
+        self.line = line
+        self.dir = dir
+
+    def asHTML(self):
+        return cgi.escape("Pre-commit tests")
+
+    def __eq__(self, other):
+        return (super(PrecommitCommand, self).__eq__(other) and
+                isinstance(other, PrecommitCommand) and
+                self.from_branch == other.from_branch and
+                self.to_branch == other.to_branch)
+
+    def getProjects(self):
+        b, config = self.getBranchConfig(self.to_branch)
+        project = config['project']
+        if project is not None:
+            return set([project])
+        else:
+            return set()
+
+    def iter_pipe_lines(self, pipe):
+        '''process the output of pipe into lines and yield them.'''
+        read_set = []
+        if pipe.fromchild:
+            read_set.append(pipe.fromchild)
+        if pipe.childerr:
+            read_set.append(pipe.childerr)
+    
+        out_data = err_data = ''
+        while read_set:
+            rlist, wlist, xlist = select.select(read_set, [], [])
+
+            if pipe.fromchild in rlist:
+                out_chunk = os.read(pipe.fromchild.fileno(), 1024)
+                if out_chunk == '':
+                    pipe.fromchild.close()
+                    read_set.remove(pipe.fromchild)
+                out_data += out_chunk
+                while '\n' in out_data:
+                    pos = out_data.find('\n')
+                    yield out_data[:pos+1]
+                    out_data = out_data[pos+1:]
+        
+            if pipe.childerr in rlist:
+                err_chunk = os.read(pipe.childerr.fileno(), 1024)
+                if err_chunk == '':
+                    pipe.childerr.close()
+                    read_set.remove(pipe.childerr)
+                err_data += err_chunk
+                while '\n' in err_data:
+                    pos = err_data.find('\n')
+                    yield err_data[:pos+1]
+                    err_data = err_data[pos+1:]
+        
+            select.select([],[],[],.1) # give a little time for buffers to fill
+        
+    def run(self):
+        super(PrecommitCommand, self).run()
+        hook = self.config['precommit_hook']
+        if not hook:
+            hook = precommit_hook
+        if hook:
+            logger.info("running precommit hook: %s" % (hook,))
+            self.output.extend(['\n', 'Executing pre-commit hook %s at %s' % (hook, time.strftime('%c')), '\n'])
+            child = self.run_in_dir(self.dir, popen2.Popen4, hook)
+            child.tochild.close()
+            for line in self.iter_pipe_lines(child):
+                self.branch_spec_handler.status.line(line)
+                self.output.append(line)
+            # self.output.extend(child.fromchild.readlines())
+            ecode = child.wait()
+            if not ((ecode is None) or (ecode == 0)):
+                self.output.append('\npre-commit hook failed with error code %d at %s\n' % (ecode - 255, time.strftime('%c')))
+                raise PQMCmdFailure(self.sender, self.successful, self.line, self.output)
+            self.output += ['\n', 'pre-commit hook succeeded at %s' % (time.strftime('%c')), '\n']
+        return self.successful, self.unrecognized, self.output
+
+
+class PQMCmdFailure(Exception):
+    def __init__(self, sender, goodcmds, badcmd, output):
+        self.sender = sender
+        self.goodcmds = goodcmds
+        self.badcmd = badcmd
+        self.output = output
+        self.args = (sender, goodcmds, badcmd, output)
+
+class PQMTlaFailure(PQMException):
+    def __init__(self, sender, output):
+        self.sender = sender
+        self.output = output
+        self.msg = str(output)
+
+>>>>>>> MERGE-SOURCE
 def popen_noshell_with_input(cmd, inputfd, *args):
     (stdin, stdout) = os.pipe()
     pid = os.fork()
@@ -183,6 +857,7 @@
 def popen_noshell(cmd, *args):
     return apply(popen_noshell_with_input, [cmd, None] + list(args))
 
+<<<<<<< TREE
 class VCSHandler:
 
     def branch_exists(self, sender, branch):
@@ -361,6 +1036,10 @@
 
 
 class Bazaar2Handler(VCSHandler):
+=======
+
+class BzrHandler(object):
+>>>>>>> MERGE-SOURCE
 
     def __init__(self):
         try:

=== modified file 'pqm/tests/test_pqm.py'
--- pqm/tests/test_pqm.py	2010-04-19 02:40:26 +0000
+++ pqm/tests/test_pqm.py	2010-05-04 17:12:27 +0000
@@ -208,12 +208,20 @@
         self.assertEqual(script.getLines(),
             [("star-merge http://www.example.com/foo/bar "
               "http://www.example.com/bar/baz")])
+<<<<<<< TREE
         self.assertEqual([MergeCommand(None,
                                        None,
                                        None,
                                        'http://www.example.com/foo/bar',
                                        'http://www.example.com/bar/baz',
                                        self.queue.manager)],
+=======
+        self.assertEqual([pqm.MergeCommand(None,
+                                           None,
+                                           None,
+                                           'http://www.example.com/foo/bar',
+                                           'http://www.example.com/bar/baz')],
+>>>>>>> MERGE-SOURCE
                          script.getCommands())
 
     def testGPGFields(self):
@@ -309,7 +317,7 @@
         return "a_sender"
 
 
-class TestCommandRunner(unittest.TestCase):
+class TestCommand(unittest.TestCase):
 
     def setUp(self):
         unittest.TestCase.setUp(self)
@@ -327,6 +335,7 @@
         self.assertEqual(star_match.group(1), 'file:///url1')
         self.assertEqual(star_match.group(2), 'file:///url2')
 
+<<<<<<< TREE
     def test_get_arch_impl(self):
         self.logs = []
         configp = ConfigParser()
@@ -342,12 +351,19 @@
                 # something went wrong other than baz not being installed.
                 raise
 
+=======
+>>>>>>> MERGE-SOURCE
     def test_check_revision(self):
         configp = ConfigParser()
         handler = pqm.BranchSpecOptionHandler(configp)
         handler._specs = {'file:///tmp/foo':{},
                           'file:///tmp/bar/':{}}
+<<<<<<< TREE
         runner = self.make_runner(MockScript(), handler, configp)
+=======
+        runner = pqm.Command(None, handler, configp)
+        runner.script = MockScript()
+>>>>>>> MERGE-SOURCE
         runner.check_target('file:///tmp/foo', 'blah')
         self.assertRaises(PQMCmdFailure,
                           runner.check_target,
@@ -362,7 +378,11 @@
     def test__make_wd_path(self):
         configp = ConfigParser()
         handler = pqm.BranchSpecOptionHandler(configp)
+<<<<<<< TREE
         runner = self.make_runner(None, handler, configp)
+=======
+        runner = pqm.Command(None, handler, configp)
+>>>>>>> MERGE-SOURCE
         self.assertEqual(runner._make_wd_path('/foo', '/foo/bar'), '/foo/foo')
         self.assertEqual(runner._make_wd_path('/foo', 'file:///foo/bar'),
                          '/foo/file')
@@ -372,7 +392,11 @@
         configp = ConfigParser()
         pqm.pqm_subdir = '/tmp' # ewww
         handler = pqm.BranchSpecOptionHandler(configp)
+<<<<<<< TREE
         runner = self.make_runner(None, handler, configp)
+=======
+        runner = pqm.Command(None, handler, configp)
+>>>>>>> MERGE-SOURCE
         self.assertEqual(runner._branch_name('foo'), 'foo')
         self.assertEqual(runner._branch_name('file:///home/bar/foo'), 'foo')
         self.assertEqual(runner._branch_name('file:///home/bar/foo'), 'foo')
@@ -381,7 +405,11 @@
         configp = ConfigParser()
         configp.readfp(StringIO(sample_config_with_workdir))
         handler = pqm.BranchSpecOptionHandler(configp)
+<<<<<<< TREE
         runner = self.make_runner(MockScript(), handler, configp)
+=======
+        runner = pqm.Command(None, handler, configp)
+>>>>>>> MERGE-SOURCE
         pqm.workdir = "test-workdir"
         pqm.branch_specs={'path':{'build_dir':'nonexistant-dir'}}
         os.mkdir("test-workdir")
@@ -393,25 +421,39 @@
     def test__get_url_override_mapper_no_overrides(self):
         configp = ConfigParser()
         handler = pqm.BranchSpecOptionHandler(configp)
+<<<<<<< TREE
         runner = self.make_runner(None, handler, configp)
         runner.configp = ConfigParser()
+=======
+        runner = pqm.Command(None, handler, configp)
+        runner.configp = pqm.ConfigParser()
+>>>>>>> MERGE-SOURCE
         expected_mapper = config_manager.URLMapper()
         self.assertEqual(expected_mapper, runner._get_url_override_mapper())
 
     def test__get_url_override_mapper(self):
         configp = ConfigParser()
         handler = pqm.BranchSpecOptionHandler(configp)
+<<<<<<< TREE
         runner = self.make_runner(None, handler, configp)
         runner.configp = ConfigParser()
+=======
+        runner = pqm.Command(None, handler, configp)
+        runner.configp = pqm.ConfigParser()
+>>>>>>> MERGE-SOURCE
         runner.configp.readfp(StringIO(sample_config_with_overrides))
         expected_mapper = config_manager.URLMapper()
         expected_mapper.add_map("sftp://host/otherpath", "/local/path")
         expected_mapper.add_map("righthandside", "scheme://something")
         self.assertEqual(expected_mapper, runner._get_url_override_mapper())
+<<<<<<< TREE
 
 
 class TestCommand(unittest.TestCase):
 
+=======
+       
+>>>>>>> MERGE-SOURCE
     def test_debug_command_sets_script_debug(self):
         configp = ConfigParser()
         pqm.pqm_subdir = '/tmp' # ewww
@@ -427,7 +469,7 @@
         self.assertTrue(script.debug)
 
 
-class FunctionalTestCommandRunner(unittest.TestCase):
+class FunctionalTestCommand(unittest.TestCase):
 
     def setUp(self):
         from bzrlib.bzrdir import BzrDir
@@ -440,6 +482,7 @@
     def tearDown(self):
         shutil.rmtree("bzrbranch")
 
+<<<<<<< TREE
     def test_get_branch_handler_arch(self):
         # I would test this, but I don't want to add a full dependency on
         # pybaz at this point
@@ -448,9 +491,12 @@
         ## TODO set a fake logger
         pass
 
+=======
+>>>>>>> MERGE-SOURCE
     def branch_url(self):
         branchurl = "file://%s" % os.path.abspath("bzrbranch")
         return branchurl.replace('\\', '/')
+<<<<<<< TREE
 
     def test_get_branch_handler_bzr_file(self):
         configp = ConfigParser()
@@ -480,6 +526,8 @@
         runner.set_current_vcs(self.branch_url(), "bzrbranch")
         self.assertNotEqual(runner.get_vcs(), None)
         self.failUnless(isinstance(runner.get_vcs(), pqm.Bazaar2Handler))
+=======
+>>>>>>> MERGE-SOURCE
 
 
 class BzrHandlerTestCase(TestCaseWithTransport):
@@ -512,7 +560,7 @@
         branch = Branch.open("bzrbranch")
         self.assertEqual(branch.repository.get_revision(branch.last_revision()).message,
                          'start branch.')
-        handler = pqm.Bazaar2Handler()
+        handler = pqm.BzrHandler()
         config = {'publish_to':'bzrbranch-public'}
         handler.commit("me", "bzrbranch", "wheee", "bzrbranch-parent", config)
         for path in ['bzrbranch', 'bzrbranch-parent', 'bzrbranch-public']:
@@ -525,7 +573,7 @@
         branch = Branch.open("bzrbranch")
         self.assertEqual(branch.repository.get_revision(branch.last_revision()).message,
                          'start branch.')
-        handler = pqm.Bazaar2Handler()
+        handler = pqm.BzrHandler()
         config = {'publish_to':'bzrbranch-public-missing'}
         self.assertRaises(pqm.PQMTlaFailure, handler.commit, "me",
                           "bzrbranch", "wheee", "bzrbranch-parent", config)
@@ -539,7 +587,7 @@
 
     def test_make_local_dir(self):
         try:
-            handler = pqm.Bazaar2Handler()
+            handler = pqm.BzrHandler()
             handler.make_local_dir("me", "bzrbranch", "proof")
             from bzrlib.branch import Branch
             branch = Branch.open("proof")
@@ -558,7 +606,7 @@
                             contrib_branch.last_revision()).message,
                          'add README')
         self.failIf(os.path.exists("bzrbranch/README"))
-        handler = pqm.Bazaar2Handler()
+        handler = pqm.BzrHandler()
         result = handler.do_star_merge("me", "branch-contributor", "bzrbranch")
         self.assertEqual(result, ["merge successful"])
         branch = Branch.open("bzrbranch")
@@ -593,6 +641,7 @@
         file.write("Boo conflict YEAH!\n")
         file.close()
         contrib_tree.commit('add conflicting README')
+<<<<<<< TREE
         handler = pqm.Bazaar2Handler()
         err = self.assertRaises(pqm.PQMTlaFailure, handler.do_star_merge, "me",
                                 "branch-contributor", "bzrbranch")
@@ -605,6 +654,10 @@
         unrelated = self.make_branch_and_tree('unrelated')
         unrelated.commit("unrelated first commit")
         handler = pqm.Bazaar2Handler()
+=======
+        handler = pqm.BzrHandler()
+        e = None
+>>>>>>> MERGE-SOURCE
         try:
             handler.do_star_merge("me", "unrelated", "bzrbranch")
         except pqm.PQMTlaFailure, e: