def check_buildbot():
    """check if buildbot command works"""
    try:
        run_cmd(["buildbot", "--version"])
    except CalledProcessError:
        log.error("FAIL: buildbot command doesn't work", exc_info=True)
        raise

    def testGitShare(self):
        shareBase = os.path.join(self.tmpdir, 'git-repos')
        rev = git.git(self.repodir, self.wc, shareBase=shareBase)
        shareDir = os.path.join(shareBase, git.get_repo_name(self.repodir))
        self.assertEquals(rev, self.revisions[-1])

        # We should see all the revisions
        revs = getRevisions(
            self.wc, branches=['origin/master', 'origin/branch2'])
        shared_revs = getRevisions(
            shareDir, branches=['origin/master', 'origin/branch2'])

        self.assertEquals(revs, shared_revs)
        self.assertEquals(revs, self.revisions)

        # Update to a different rev
        rev = git.git(self.repodir, self.wc,
                      revision=self.revisions[0], shareBase=shareBase)
        self.assertEquals(rev, self.revisions[0])
        self.assertFalse(os.path.exists(os.path.join(self.wc, 'newfile')))

        # Add a commit to the original repo
        newfile = os.path.join(self.repodir, 'newfile')
        touch(newfile)
        run_cmd(['git', 'add', 'newfile'], cwd=self.repodir)
        run_cmd(['git', 'commit', '-q', '-m', 'add newfile'], cwd=self.repodir)
        new_rev = getRevisions(self.repodir)[-1]

        # Update to the new rev
        rev = git.git(
            self.repodir, self.wc, revision=new_rev, shareBase=shareBase)
        self.assertEquals(rev, new_rev)
        self.assertTrue(os.path.exists(os.path.join(self.wc, 'newfile')))

def rsyncFilesByPattern(server, userName, sshKey, source_dir, target_dir,
                        pattern):
    cmd = ['rsync', '-e',
           'ssh -l %s -oIdentityFile=%s' % (userName, sshKey),
           '-av', '--include=%s' % pattern, '--include=*/', '--exclude=*',
           '%s:%s' % (server, source_dir), target_dir]
    run_cmd(cmd)

    def testOutofSyncMirrorFailingMaster(self):
        # First create the mirror
        mirror = os.path.join(self.tmpdir, "repo2")
        clone(self.repodir, mirror)

        shareBase = os.path.join(self.tmpdir, "share")
        os.mkdir(shareBase)
        mercurial(self.repodir, self.wc, shareBase=shareBase, mirrors=[mirror])

        # Create a bundle
        bundle = os.path.join(self.tmpdir, "bundle")
        run_cmd(["hg", "bundle", "-a", bundle], cwd=self.repodir)

        # Move our repodir out of the way so that pulling/cloning from it fails
        os.rename(self.repodir, self.repodir + "-bad")

        # Try and update to a non-existent revision using our mirror and
        # bundle, with the master failing. We should fail
        self.assertRaises(
            subprocess.CalledProcessError,
            mercurial,
            self.repodir,
            self.wc,
            shareBase=shareBase,
            mirrors=[mirror],
            bundles=[bundle],
            revision="1234567890",
        )

def getPreviousBuildID(download_base_url, download_subdir):
    """Figure out what the previous buildid is"""
    if os.path.exists('previous.apk'):
        os.remove('previous.apk')
    run_cmd(['wget', '-O', 'previous.apk',
         '%s/nightly/latest-%s/gecko-unsigned-unaligned.apk' % (download_base_url, download_subdir)])
    return parseApk('previous.apk')[0]

    def bump_and_tag(repo, attempt, config, relbranch, revision, tags,
                     defaultBranch):
        relbranchChangesets = len(tags)
        defaultBranchChangesets = 0

        if relbranch in get_branches(reponame):
            update(reponame, revision=relbranch)
        else:
            update(reponame, revision=revision)
            run_cmd(['hg', 'branch', relbranch], cwd=reponame)

        if len(bumpFiles) > 0:
            # Bump files on the relbranch, if necessary
            bump(reponame, bumpFiles, 'version')
            run_cmd(['hg', 'diff'], cwd=repo)
            try:
                get_output(['hg', 'commit', '-u', config['hgUsername'],
                            '-m', getBumpCommitMessage(config['productName'], config['version'])],
                           cwd=reponame)
                relbranchChangesets += 1
                revision = get_revision(reponame)
            except subprocess.CalledProcessError, e:
                # We only want to ignore exceptions caused by having nothing to
                # commit, which are OK. We still want to raise exceptions caused
                # by any other thing.
                if e.returncode != 1 or "nothing changed" not in e.output:
                    raise

def recreate_repos(repoSetupConfig):
    hgHost = repoSetupConfig['hgHost']
    repoPath = repoSetupConfig['repoPath']
    hgUserName = repoSetupConfig['hgUserName']
    hgSshKey = path.join(path.expanduser("~"), ".ssh",
                         repoSetupConfig['hgSshKey'])

    for repo in repoSetupConfig['reposToClone'].keys():
        maybe_delete_repo(hgHost, hgUserName, hgSshKey, repo, repoPath)
        clone_repo(hgHost, hgUserName, hgSshKey, repo)

    run_cmd(['sleep', '600'])
    allTags = []

    for repo in repoSetupConfig['reposToClone'].keys():
        if repoSetupConfig['reposToClone'][repo].get('overrides'):
            tags = bump_configs(
                hgHost, hgUserName, hgSshKey, repo, repoPath,
                repoSetupConfig['reposToClone'][repo]['overrides'],
                repoSetupConfig['reposToClone'][repo].get('nobump_overrides', []))
            allTags.extend(tags)
    log.info('Tagging using %s' % ' '. join(allTags))

    for repo in repoSetupConfig['reposToClone'].keys():
        if repoSetupConfig['reposToClone'][repo].get('doTag'):
            tag_repo(hgHost, hgUserName, hgSshKey, repo, repoPath, allTags)

def cleanOutgoingRevs(reponame, remote, username, sshKey):
    outgoingRevs = retry(out, kwargs=dict(src=reponame, remote=remote,
                                          ssh_username=username,
                                          ssh_key=sshKey))
    for r in reversed(outgoingRevs):
        run_cmd(['hg', '--config', 'extensions.mq=', 'strip', '-n',
                 r[REVISION]], cwd=reponame)

def check_buildbot():
    """check if buildbot command works"""
    try:
        run_cmd(['buildbot', '--version'])
    except CalledProcessError:
        print "FAIL: buildbot command doesn't work"
        raise

 def process_configs(repo, attempt):
     """Helper method that encapsulates all of the things necessary
        to run release runner for all releases."""
     log.info("Bumping %s, attempt #%s" % (repo, attempt))
     for release in rr.new_releases:
         rr.update_status(release, 'Writing configs')
         l10nContents = rr.get_release_l10n(release['name'])
         tags.extend(getTags(
             getBaseTag(release['product'], release['version']),
             release['buildNumber'])
         )
         update(configs_workdir, revision='default')
         cfgFile = getReleaseConfigName(
             release['product'], path.basename(release['branch']),
             release['version'], staging)
         bump_configs(release=release, cfgFile=cfgFile,
                      l10nContents=l10nContents, workdir=configs_workdir,
                      hg_username=hg_username,
                      productionBranch=buildbot_configs_branch)
         rr.update_status(release, 'Running release sanity')
         rs_args = get_release_sanity_args(configs_workdir, release,
                                           cfgFile, masters_json,
                                           buildbot_configs_branch)
         release_sanity_script = "%s/buildbot-helpers/release_sanity.py" % tools_workdir
         run_cmd(['python', release_sanity_script] + rs_args +
                 ['--dry-run'])
         rr.update_status(
             release, 'Waiting for other releases to run release sanity'
         )

def checkoutSVN(targetSVNDirectory, svnURL):
    """
    Checkout the product details SVN
    """
    if not os.path.isdir(targetSVNDirectory):
        cmd = ["svn", "co", svnURL, targetSVNDirectory]
        run_cmd(cmd)

 def testCommitWithUser(self):
     run_cmd(['touch', 'newfile'], cwd=self.repodir)
     run_cmd(['hg', 'add', 'newfile'], cwd=self.repodir)
     rev = commit(self.repodir, user='unittest', msg='new stuff!')
     info = getRevInfo(self.repodir, rev)
     self.assertEquals(info['user'], 'unittest')
     self.assertEquals(info['msg'], 'new stuff!')

    def testMercurialChangeRepo(self):
        # Create a new repo
        old_env = os.environ.copy()
        if 'HG_SHARE_BASE_DIR' in os.environ:
            del os.environ['HG_SHARE_BASE_DIR']

        try:
            repo2 = os.path.join(self.tmpdir, 'repo2')
            run_cmd(['%s/init_hgrepo.sh' % os.path.dirname(__file__), repo2])

            self.assertNotEqual(self.revisions, getRevisions(repo2))

            # Clone the original repo
            mercurial(self.repodir, self.wc)
            self.assertEquals(getRevisions(self.wc), self.revisions)
            open(os.path.join(self.wc, 'test.txt'), 'w').write("hello!")

            # Clone the new one
            mercurial(repo2, self.wc)
            self.assertEquals(getRevisions(self.wc), getRevisions(repo2))
            # Make sure our local file went away
            self.failUnless(
                not os.path.exists(os.path.join(self.wc, 'test.txt')))
        finally:
            os.environ.clear()
            os.environ.update(old_env)

    def testShareExtraFiles(self):
        shareBase = os.path.join(self.tmpdir, 'share')
        backup = os.path.join(self.tmpdir, 'backup')

        # Clone the original repo
        mercurial(self.repodir, self.wc, shareBase=shareBase)

        clone(self.repodir, backup)

        # Make the working repo have a new file. We need it to have an earlier
        # timestamp (yesterday) to trigger the odd behavior in hg
        newfile = os.path.join(self.wc, 'newfile')
        touch(newfile, timestamp=yesterday_timestamp())
        run_cmd(['hg', 'add', 'newfile'], cwd=self.wc)
        run_cmd(['hg', 'commit', '-m', '"add newfile"'], cwd=self.wc)

        # Reset the share base to remove the 'add newfile' commit. We
        # overwrite repodir with the backup that doesn't have the commit,
        # then clone the repodir to a throwaway dir to create the new
        # shareBase. Now self.wc still points to shareBase, but the
        # changeset that self.wc was on is lost.
        shutil.rmtree(self.repodir)
        shutil.rmtree(shareBase)
        clone(backup, self.repodir)
        throwaway = os.path.join(self.tmpdir, 'throwaway')
        mercurial(self.repodir, throwaway, shareBase=shareBase)

        # Try and update our working copy
        mercurial(self.repodir, self.wc, shareBase=shareBase)

        self.assertFalse(os.path.exists(os.path.join(self.wc, 'newfile')))

 def testCommit(self):
     newfile = os.path.join(self.repodir, 'newfile')
     touch(newfile)
     run_cmd(['hg', 'add', 'newfile'], cwd=self.repodir)
     rev = commit(self.repodir, user='unittest', msg='gooooood')
     info = getRevInfo(self.repodir, rev)
     self.assertEquals(info['msg'], 'gooooood')

    def testPullDefault(self):
        clone(self.repodir, self.wc)
        run_cmd(["hg", "tag", "-f", "TAG1"], cwd=self.repodir)
        revisions = getRevisions(self.repodir)

        rev = pull(self.repodir, self.wc, revision="default")
        self.assertEquals(rev, revisions[0])
        self.assertEquals(getRevisions(self.wc), revisions)

 def testPushWithForce(self):
     clone(self.repodir, self.wc, revision=self.revisions[0],
           clone_by_rev=True)
     newfile = os.path.join(self.wc, 'newfile')
     touch(newfile)
     run_cmd(['hg', 'add', 'newfile'], cwd=self.wc)
     run_cmd(['hg', 'commit', '-m', '"re-add newfile"'], cwd=self.wc)
     push(self.repodir, self.wc, push_new_branches=False, force=True)

 def _run_hg(cls, command, repo=None, want_output=False):
     cmd = [cls.hg, '--config', 'extensions.mq=']
     if repo:
         cmd.extend(["-R", repo])
     if want_output:
         return get_output(cmd + command)
     else:
         run_cmd(cmd + command)

    def setUp(self):
        self.tmpdir = tempfile.mkdtemp()
        self.repodir = os.path.join(self.tmpdir, "repo")
        run_cmd(["%s/init_hgrepo.sh" % os.path.dirname(__file__), self.repodir])

        self.revisions = getRevisions(self.repodir)
        self.wc = os.path.join(self.tmpdir, "wc")
        self.pwd = os.getcwd()

def purge(dest):
    """Purge the repository of all untracked and ignored files."""
    try:
        run_cmd(['hg', '--config', 'extensions.purge=', 'purge',
                 '-a', '--all', dest], cwd=dest)
    except subprocess.CalledProcessError, e:
        log.debug('purge failed: %s' % e)
        raise