Пример #1
0
    def commit(self, objects, message):
        # validate commit message
        if not message or not isinstance(message, basestring):
            raise ValueError("Commit message should not be empty or not string")

        env = os.environ.copy()
        env.update({
                'GIT_WORK_TREE': self.repo,
                'GIT_DIR': '%s/.git' % self.repo,
        })

        git.gc("--prune", _env=env)
        git.checkout("HEAD", _env=env)

        # pull and push from and to the remote
        git.pull("origin", "master", _env=env)

        for obj in objects:
            git.add("-A", obj, _env=env)

        try:
            git.commit("-m", message, _env=env)
        except Exception:
            pass

        git.push(_env=env)
Пример #2
0
def release():
    """Release/publish the code.
    """

    # Rebase and push the master with tags to origin.
    print("Here are the remaining TODO items:")
    print(bash('TODO.sh'))
    print()
    if not util.yes(
            "Do you still want to rebase and push the master with tags "
            "to origin (y/n)?"):
        util.delayed_exit()
    git.rebase('-i', 'origin/master')
    git.push('--tags', 'origin', 'master')

    # Upload to PyPI.
    if not util.yes("Do you want to upload to PyPI (this is permanent!) "
                    "(y/n)?"):
        util.delayed_exit()
    setup.sdist.upload()

    # Reset the version number.
    # In CHANGES.txt:
    newheading = ('TBD (in `GitHub <https://github.com/kdavies4/natu>`_ '
                  'only) -- Updates:')
    newlink = ('.. _vx.x.x: '
               'https://github.com/kdavies4/natu/archive/vx.x.x.zip')
    rpls = [(r'(<http://semver.org>`_\.)', r'\1\n\n' + newheading),
            (r'(Initial release\n\n\n)', r'\1%s\n' % newlink)]
    util.replace('CHANGES.txt', rpls)
Пример #3
0
    def commit(self, objects, message):
        # validate commit message
        if not message or not isinstance(message, basestring):
            raise ValueError(
                "Commit message should not be empty or not string")

        env = os.environ.copy()
        env.update({
            'GIT_WORK_TREE': self.repo,
            'GIT_DIR': '%s/.git' % self.repo,
        })

        git.gc("--prune", _env=env)
        git.checkout("HEAD", _env=env)

        # pull and push from and to the remote
        git.pull("origin", "master", _env=env)

        for obj in objects:
            git.add("-A", obj, _env=env)

        try:
            git.commit("-m", message, _env=env)
        except Exception:
            pass

        git.push(_env=env)
Пример #4
0
Файл: code.py Проект: joewa/natu
def release():
    """Release/publish the code.
    """

    # Rebase and push the master with tags to origin.
    print("Here are the remaining TODO items:")
    print(bash('TODO.sh'))
    print()
    if not util.yes("Do you still want to rebase and push the master with tags "
                    "to origin (y/n)?"):
        util.delayed_exit()
    git.rebase('-i', 'origin/master')
    git.push('--tags', 'origin', 'master')

    # Upload to PyPI.
    if not util.yes("Do you want to upload to PyPI (this is permanent!) "
                    "(y/n)?"):
        util.delayed_exit()
    setup.sdist.upload()

    # Reset the version number.
    # In natu/__init__.py:
    set_version('None')
    # In CHANGES.txt:
    newheading = ('TBD (in `GitHub <https://github.com/kdavies4/natu>`_ '
                  'only) -- Updates:')
    newlink = ('.. _vx.x.x: '
               'https://github.com/kdavies4/natu/archive/vx.x.x.zip')
    rpls = [(r'(<http://semver.org>`_\.)',
             r'\1\n\n' + newheading),
            (r'(Initial release\n\n\n)',
             r'\1%s\n' % newlink)]
    util.replace('CHANGES.txt', rpls)
def main():
    """
    Requires youtube uploader script from
    https://github.com/tokland/youtube-upload
    """

    from subprocess import Popen, PIPE
    import glob
    from sh import git

    yt_ids = []
    for fname in glob.glob('*.webm'):
        title = fname.replace('.webm','').replace('_',' ')
        command = 'youtube-upload --title="'+title+'" '+fname
        p = Popen(command,stdout=PIPE,shell=True)
        out = p.communicate()
        yt_ids.append(str(out[0].rstrip()).replace("b'",'').replace("'",''))
    readme_content = '# White dwarf nova\n'
    for idd in yt_ids:
        readme_content += '[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/'+idd+'/0.jpg)](http://www.youtube.com/watch?v='+idd+')\n'
    with open('README.md','w') as f:
        f.write(readme_content)
    git.add('README.md')
    git.commit(m='update videos')
    git.push()
def main():
    """
    Requires youtube uploader script from
    https://github.com/tokland/youtube-upload
    """

    from subprocess import Popen, PIPE
    import glob
    from sh import git

    yt_ids = []
    for fname in glob.glob("*.webm"):
        title = fname.replace(".webm", "").replace("_", " ")
        command = 'youtube-upload --title="' + title + '" ' + fname
        p = Popen(command, stdout=PIPE, shell=True)
        out = p.communicate()
        yt_ids.append(str(out[0].rstrip()).replace("b'", "").replace("'", ""))
    readme_content = "# White dwarf nova\n"
    for idd in yt_ids:
        readme_content += (
            "[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/"
            + idd
            + "/0.jpg)](http://www.youtube.com/watch?v="
            + idd
            + ")\n"
        )
    with open("README.md", "w") as f:
        f.write(readme_content)
    git.add("README.md")
    git.commit(m="update videos")
    git.push()
Пример #7
0
    def add_to_blacklist(self, items_to_blacklist, username, code_permissions):
        # Check if we're on master
        if git("rev-parse", "--abbrev-ref", "HEAD").strip() != "master":
            return (False, "Not currently on master.")

        # Check that we're up-to-date with origin (GitHub)
        git.remote.update()
        if git("rev-parse", "refs/remotes/origin/master").strip() != git("rev-parse", "master").strip():
            return (False, "HEAD isn't at tip of origin's master branch")

        # Check that blacklisted_websites.txt isn't modified locally. That could get ugly fast
        if "blacklisted_websites.txt" in git.status():  # Also ugly
            return (False, "blacklisted_websites.txt modified locally. This is probably bad.")

        # Store current commit hash
        current_commit = git("rev-parse", "HEAD").strip()

        # Add items to file
        with open("blacklisted_websites.txt", "a+") as blacklisted_websites:
            last_character = blacklisted_websites.read()[-1:]
            if last_character != "\n":
                blacklisted_websites.write("\n")
            blacklisted_websites.write("\n".join(items_to_blacklist) + "\n")

        # Checkout a new branch (mostly unnecessary, but may help if we create PRs in the future
        branch = "auto-blacklist-{0}".format(str(time.time()))
        git.checkout("-b", branch)

        # Clear HEAD just in case
        git.reset("HEAD")

        git.add("blacklisted_websites.txt")
        git.commit("-m", "Auto blacklist of {0} by {1} --autopull".format(", ".join(items_to_blacklist), username))

        if code_permissions:
            git.checkout("master")
            git.merge(branch)
            git.push()
        else:
            git.push("origin", branch)
            git.checkout("master")

            if GlobalVars.github_username is None or GlobalVars.github_password is None:
                return (False, "tell someone to set a GH password")

            payload = {"title": "{0}: Blacklist {1}".format(username, ", ".join(items_to_blacklist)),
                       "body": "{0} requests blacklist of domains: \n\n - {1}".format(username, "\n - ".join(items_to_blacklist)),
                       "head": branch,
                       "base": "master"}
            response = requests.post("https://api.github.com/repos/Charcoal-SE/SmokeDetector/pulls", auth=HTTPBasicAuth(GlobalVars.github_username, GlobalVars.github_password), data=json.dumps(payload))
            print(response.json())
            return (True, "You don't have code privileges, but I've [created a pull request for you]({0}).".format(response.json()["html_url"]))

        git.checkout(current_commit)  # Return to old commit to await CI. This will make Smokey think it's in reverted mode if it restarts

        if not code_permissions:
            return (False, "Unable to perform action due to lack of code-level permissions. [Branch pushed](https://github.com/Charcoal-SE/SmokeDetector/tree/{0}), PR at your leisure.".format(branch))

        return (True, "Blacklisted {0} - the entry will be applied via autopull if CI succeeds.".format(", ".join(items_to_blacklist)))
Пример #8
0
def generate_csv(output_directory='./'):
    # Set up root data dir
    root_filename = ROOT + '/cfb-data/automated/wiki/' + ROOT + '/'

    # Clone data repository for updates - continue if already exists
    from sh import git
    try:
        shutil.rmtree(ROOT + '/cfb-data/')
    except:
        pass
    git.clone(
        'https://' + os.getenv('MACHINE_AUTH') +
        '@github.com/coffenbacher/cfb-data.git', ROOT + '/cfb-data/')

    # Create our root if required
    if not os.path.exists(root_filename):
        os.makedirs(root_filename)

    # Set up logging
    logging.basicConfig(
        level='WARNING',
        #format='%(asctime)s %(levelname)-8s %(message)s',
        #datefmt='%a, %d %b %Y %H:%M:%S',
        filename=root_filename + ROOT + '.log',
        filemode='w')

    # Extract all current names from Wiki
    data = FN()

    # Write everything to csv
    with open(root_filename + ROOT + '.csv', 'w') as csvfile:
        writer = csv.DictWriter(csvfile,
                                fieldnames=FIELDNAMES,
                                extrasaction='ignore')
        for d in data:
            asci = dict([(unidecode(k), unidecode(unicode(v)))
                         for k, v in d.items()])
            writer.writerow(asci)
            # [unidecode(unicode(d.get(field))) for field in FIELDNAMES]

    # Write everything to json
    with open(root_filename + ROOT + '.json', 'w') as jsonfile:
        relevant = [{f: d.get(f, None) for f in FIELDNAMES} for d in data]
        jsonfile.write(json.dumps(relevant))

    with open(root_filename + ROOT + '_meta.json', 'w') as metafile:
        d = {
            'created': datetime.now().strftime('%x %X'),
            'rows': len(data),
            'headers': ','.join(FIELDNAMES),
        }
        metafile.write(json.dumps(d))

    git = git.bake(**{
        'git-dir': ROOT + '/cfb-data/.git/',
        'work-tree': ROOT + '/cfb-data'
    })
    git.commit(m='Auto updating %s data' % ROOT, a=True)
    git.push('origin', 'master')
Пример #9
0
 def publish_site(self):
       tmp_branch = '__dynamo_deploy__'
       detached_branch = None
       
       git.checkout(self.target_branch)
       self._add_and_commit_site('dist')
       git.push('origin', self.target_branch)
       git.checkout('@{-1}')
Пример #10
0
def sync(event, context):
    event = Event(event)
    sourcerepo = SourceRepo(event)

    with tempfile.TemporaryDirectory() as tmpdir:
        git.clone('--mirror', event.clone_url, _cwd=tmpdir)
        git.push('--mirror', sourcerepo.url, _cwd=tmpdir)

    return
Пример #11
0
def push():
    print("git push")
    try: git.push()
    except:
        try:
            branch_name = branchName()
            print("git push -u gh " + branch_name)
            try: git.push("-u", "gh", branch_name)
            except : print("Nothing to push")
        except: print("Nothing has been created")
Пример #12
0
def main():
    git.checkout("-b", "task_1")

    f = open("file1.txt", "w")
    f.write("here is a file")
    f.close()
    git.commit("-am", "commited new text file1")
    git.push("--set-upstream", "origin", "task1")

    git.checkout("-")
Пример #13
0
def update(conf, args):
  '''Apply updates from the upstream repository.'''

  print('Checking for updates...')

  # fetch changes from the canonical repo
  git.fetch(constants.GIT_REMOTE, no_tags=True, quiet=True)

  # get a list of the commit messages for the incoming changes
  updates = git('--no-pager', 'log', '..FETCH_HEAD', oneline=True)
  updates = [tuple(m.split(None, 1)) for m in updates.splitlines()]

  # print out a list of the incoming updates
  if len(updates) > 0:
    print('Available updates:')

    max_updates = 10
    for commit, msg in updates[:max_updates]:
      print(color.yellow('*'), msg)

    # print a special message if too many updates are available
    if len(updates) > max_updates:
      print('...and', color.green(len(updates) - max_updates), 'more!')
      print('Run `git log ..FETCH_HEAD` to see the full list')

    # bail if we have uncommitted changes (git exits non-0 in this case)
    if git.diff(exit_code=True, quiet=True, _ok_code=(0, 1)).exit_code != 0:
      raise ValueError('The repository has uncommitted changes. Handle them, '
        'then try updating again.')

    print('Applying the update...')

    # stash _all_ changes to the repo
    git.stash(include_untracked=True, all=True, quiet=True)

    # squash all the fetched commits together and merge them into master
    git.merge('@{u}', squash=True, quiet=True)

    # add a nice update commit that includes the latest upstream commit hash
    commit_message = 'Update dotparty to %s' % updates[0][0]
    git.commit(m=commit_message, quiet=True)

    # TODO: if squash merge failed, roll back to the pre-update state and
    # complain with instructions for the user to do their own update.

    # un-stash all our old changes
    git.stash('pop', quiet=True)

    # push our changes back up to the remote
    git.push(quiet=True)

    print('Update successful!')
  else:
    print('Already up-to-date!')
Пример #14
0
def _release(language, message, channel):
    print message, "...",
    if _is_dirty():
        sys.exit("Repo must be in clean state before deploying. Please commit changes.")
    _generate_yaml(language, channel)

    if _is_dirty():
        git.add('.travis.yml')
    git.commit(m=message, allow_empty=True)
    git.pull(rebase=True)
    git.push()
    print "done."
Пример #15
0
Файл: roles.py Проект: gmr/remy
    def update_roles(self):
        os.chdir('%s/%s' % (self.repo_path, self.ROLES))
        git.pull('-f', '-u', 'origin', 'master')
        os.chdir(self.repo_path)

        message = '%s %s %s %s' % (self.UPDATE, self.ROLES, 'to',
                                   self.get_submodule_hash(self.ROLES))
        git.commit('-m', message, '.gitmodules', self.ROLES)
        sys.stdout.write('Committed %s [%s]\n' % (self.ROLES, message))
        try:
            git.push('origin', 'master')
        except sh.ErrorReturnCode_1:
            pass
Пример #16
0
def migrate_for_path(packagepath, use_https):
    _, name, _ = get_package_info(packagepath)
    destination = os.path.join(destinationRoot, name)
    if not os.path.exists(destination):  # Only do conversion is path does not yet exist
        print "Migrating {0} to {1} ...".format(packagepath, destination)
        #import ipdb; ipdb.set_trace()
        migrate_repo(packagepath, destination, use_https)
        print "-" * 5, name, "done", "-"*5
    else: 
        print "{0} already migrated at {1}. git svn rebase-ing instead to bring up to date".format(packagepath, destination)
        git.pull("origin", "master")
        git.svn.rebase()
        git.push("origin", "master")
Пример #17
0
def initialize_git_repository() -> None:
    """Prepare the git repository."""
    print("    * Initializing the project git repository")

    try:
        git.init()
        git.remote(
            "add",
            "origin",
            "[email protected]:{{ cookiecutter.github_user }}/"
            "{{ cookiecutter.project_slug }}.git",
        )
        git.add(".")
        git.commit("-m", "feat: create initial project structure")
        git.checkout("-b", "gh-pages")
        git.checkout("-b", "feat/initial_iteration")

        print("    * Pushing initial changes to master")
        git.push("--force", "--set-upstream", "origin", "master")
        git.push("--force", "--set-upstream", "origin", "gh-pages")
        git.push("--force", "--set-upstream", "origin",
                 "feat/initial_iteration")
        git.push("--force")
    except sh.ErrorReturnCode as error:
        print("There was an error creating the Git repository.")
        print(str(error.stderr, "utf8"))
        sys.exit(1)
Пример #18
0
def _release(language, message, channel):
    print message, "...",
    if _is_dirty():
        sys.exit(
            "Repo must be in clean state before deploying. Please commit changes."
        )
    _generate_yaml(language, channel)

    if _is_dirty():
        git.add('.travis.yml')
    git.commit(m=message, allow_empty=True)
    git.pull(rebase=True)
    git.push()
    print "done."
Пример #19
0
    def install_app(self, appid, pdpobject):
        print "Creating app : %s on heroku" % appid
        r = self._create_app(appid)
        if r.ok:
            print "Successfully created"
        else:
            print "Error creating application"
            print r.status_code, r.text
            return

        resp = r.json()

        git_url = resp["git_url"]
        web_url = resp["web_url"]
        print "Staging PDP archive.."
        print "PDP archive is at : %s" % pdpobject.pdpdir
        print "Configuring git.."
        cwd = os.getcwd()
        os.chdir(pdpobject.pdpdir)
        from sh import git
        git.init()

        print "Invoking the right artifact handler"
        plan = pdpobject.plan
        for a in plan.artifacts:
            h = self.handler_map.get(a.type)
            if h is None:
                raise NotImplementedError("No handler for artifact type : %s" %
                                          a.type)
            ho = h(pdpobject, a)
            ho.handle_artifact()

        print "Configuring git remote.."
        git.remote.add("heroku", git_url)

        def process_output(line):
            print(line)

        print "Adding files to repo"
        git.add(".")
        print "Committing to local repo"
        git.commit("-m", "Initial commit")
        print "Pushing to heroku"
        git.push("-u", "heroku", "master", _out=process_output, _tty_out=True)

        print "Uploaded app successfully.."
        print "App is available at : %s" % web_url

        return appid, git_url, web_url
Пример #20
0
def reply_comment_email(from_email, subject, message):
    try:
        m = re.search('\[(\d+)\-(\w+)\]', subject)
        branch_name = m.group(1)
        article = m.group(2)

        message = decode_best_effort(message)

        # safe logic: no answer or unknown answer is a go for publishing
        if message[:2].upper() == 'NO':
            logger.info('discard comment: %s' % branch_name)
            email_body = get_template('drop_comment').render(original=message)
            mail(pecosys.get_config('post', 'from_email'),
                 pecosys.get_config('post', 'to_email'),
                 'Re: ' + subject, email_body)
        else:
            if pecosys.get_config("git", "disabled"):
                logger.debug("GIT usage disabled (debug mode)")
            else:
                git.merge(branch_name)
                if pecosys.get_config("git", "remote"):
                    git.push()
                logger.info('commit comment: %s' % branch_name)

                # execute post-commit command asynchronously
                postcommand = pecosys.get_config('post', 'postcommand')
                if postcommand:
                    executor.execute(postcommand)

            # send approval confirmation email to admin
            email_body = get_template('approve_comment').render(original=message)
            mail(pecosys.get_config('post', 'from_email'),
                 pecosys.get_config('post', 'to_email'),
                 'Re: ' + subject, email_body)

            # notify reader once comment is published
            reader_email, article_url = get_email_metadata(message)
            if reader_email:
                notify_reader(reader_email, article_url)

            # notify subscribers every time a new comment is published
            notify_subscribers(article)

        if pecosys.get_config("git", "disabled"):
            logger.debug("GIT usage disabled (debug mode)")
        else:
            git.branch("-D", branch_name)
    except:
        logger.exception("new email failure")
Пример #21
0
def migrate_repo(packagepath,
                 destination_path,
                 use_https,
                 authors="~/ros/fuerte/tue/authors.txt"):
    """#The process to migrate a project is:
    # Create a new repository.
    $ git svn clone <svn_url> <destination_path>
    $ cd ~/ros/fuerte/tue/git/challenge_cleanup
    $ git remote add origin <repo https url>
    $ git pull origin master
    $ git push origin master"""

    authors = os.path.expanduser(authors)

    svn_url = svnurl_for_path(packagepath)
    language, name, description = get_package_info(packagepath)

    try:
        repo = create_repo(name, description, language=language)
    except github.GithubException as e:
        if e.status == 422:
            cont = raw_input(
                "The repo has an invalid field, it could already exist. Please verify and press 'c' to continue without first creating the repo: "
            )
            if 'c' in cont:
                repo = tue.get_repo(name)
            else:
                sys.stderr.write("Could not migrate {0}".format(name))
                return

    print "git svn clone {0} {1} A={2}".format(svn_url, destination_path,
                                               authors)
    git.svn.clone(svn_url, destination_path, A=authors)

    cd(destination_path)

    if use_https:
        git_url = repo.clone_url
    else:
        git_url = repo.ssh_url

    print "git remote add origin {0}".format(git_url)
    git.remote.add("origin", git_url)

    print "git pull origin master"
    git.pull("origin", "master")

    print "git push origin master"
    git.push("origin", "master")
Пример #22
0
    def install_app(self, appid, pdpobject):
        print "Creating app : %s on heroku" % appid
        r = self._create_app(appid)
        if r.ok:
            print "Successfully created"
        else:
            print "Error creating application"
            print r.status_code, r.text
            return

        resp = r.json()

        git_url = resp["git_url"]
        web_url = resp["web_url"]
        print "Staging PDP archive.."
        print "PDP archive is at : %s" % pdpobject.pdpdir
        print "Configuring git.."
        cwd = os.getcwd()
        os.chdir(pdpobject.pdpdir)
        from sh import git
        git.init()

        print "Invoking the right artifact handler"
        plan = pdpobject.plan
        for a in plan.artifacts:
            h = self.handler_map.get(a.type)
            if h is None:
                raise NotImplementedError("No handler for artifact type : %s" % a.type)
            ho = h(pdpobject, a)
            ho.handle_artifact()

        print "Configuring git remote.."
        git.remote.add("heroku", git_url)


        def process_output(line):
            print(line)

        print "Adding files to repo"
        git.add(".")
        print "Committing to local repo"
        git.commit("-m", "Initial commit")
        print "Pushing to heroku"
        git.push("-u", "heroku", "master", _out=process_output, _tty_out=True)

        print "Uploaded app successfully.."
        print "App is available at : %s" % web_url

        return appid, git_url, web_url
Пример #23
0
def migrate_for_path(packagepath, use_https):
    _, name, _ = get_package_info(packagepath)
    destination = os.path.join(destinationRoot, name)
    if not os.path.exists(
            destination):  # Only do conversion is path does not yet exist
        print "Migrating {0} to {1} ...".format(packagepath, destination)
        #import ipdb; ipdb.set_trace()
        migrate_repo(packagepath, destination, use_https)
        print "-" * 5, name, "done", "-" * 5
    else:
        print "{0} already migrated at {1}. git svn rebase-ing instead to bring up to date".format(
            packagepath, destination)
        git.pull("origin", "master")
        git.svn.rebase()
        git.push("origin", "master")
Пример #24
0
    def run_completed(cls):
        if settings.TASK_CONFIG_BACKUP_DISABLE_GIT:
            for repository in Repository.objects.all():
                repository.lock.release()
            return

        for repository in Repository.objects.all():
            repository.lock.acquire()

        for device_group in DeviceGroup.objects.all():
            os.chdir(device_group.repository.path)
            git.push()

        for repository in Repository.objects.all():
            repository.lock.release()
Пример #25
0
    def _git_commit(commit_message):
        """
        Do a git commit in the current directory with the given commit
        message (without adding any changes). Instead of using a Git wrapper
        library, we directly call the Git binaries using :mod:`sh`, which
        ensures that error return codes are either handled or raised.

        If the :option:`DEBUG` setting is set, a Git push is attempted after
        commiting.

        Args:
            commit_message (str): Single-line commit message

        Returns:
            *True* if a commit has been made and `False` if there weren't any
            changes.

        Raises:
            :exc:`sh.ErrorReturnCode` exception in case of failure.

        """

        # This is, of course, not the most sophisticated approach at
        # interacting with Git but hey, it's simple and it works. Any error
        # code != 0 results in an exception, so there's little risk of
        # silent failure. We should probably replace this with GitPython or
        # any of the full-featured command-line wrappers at some point in
        # the future, but as long as all we're doing is automated commits,
        # it's perfectly fine.

        # Check if there are any staged changes, abort if not (git commit
        # would return an error otherwise).

        if len(git("diff-index", "--name-only", "HEAD", "--")):
            git.commit(message=commit_message)

            # Doing a git push inside the handler means that the entire task
            # would fail if the push fails. Doing a push once per run is
            # sufficient, so only push inside the task handler in debug mode.

            if settings.DEBUG:
                git.push()

            changes = True
        else:
            changes = False

        return changes
Пример #26
0
 def create_branch(self, name, head):
     if self.lookup_branch(name):
         raise GlError(
             'Branch {0} already exists in remote repository {1}'.format(
                 name, self.name))
     # Push won't let us push the creation of a new branch from a SHA. So we
     # create a temporary local ref, make it point to the commit, and do the
     # push
     tmp_b = self.gl_repo.create_branch('gl_tmp_ref', head)
     try:
         git.push(self.name, '{0}:{1}'.format(tmp_b, name))
         return self.lookup_branch(name)
     except ErrorReturnCode as e:
         raise GlError(stderr(e))
     finally:
         tmp_b.delete()
Пример #27
0
    def push(self, username="******", password="******"):
        """Push to  remote."""
        def line_proc(line, stdin):

            if "Username for" in line:
                stdin.put(username + "\n")

            elif "Password for" in line:
                stdin.put(password + "\n")

            else:
                print "git-push: ", line.strip()

        rcv = self.char_to_line(line_proc)

        try:
            # This is a super hack. See http://amoffat.github.io/sh/tutorials/2-interacting_with_processes.html
            # for some explaination.
            p = git.push('-u',
                         'origin',
                         'master',
                         _out=rcv,
                         _out_bufsize=0,
                         _tty_in=True)
            p.exit_code
        except ErrorReturnCode_128:
            raise Exception(
                """Push to repository repository failed. You will need to store or cache credentials.
            You can do this by using ssh, .netrc, or a credential maanger.
            See: https://www.kernel.org/pub/software/scm/git/docs/gitcredentials.html"""
            )

        return True
Пример #28
0
 def create_branch(self, name, head):
   if self.lookup_branch(name):
     raise GlError(
         'Branch {0} already exists in remote repository {1}'.format(
             name, self.name))
   # Push won't let us push the creation of a new branch from a SHA. So we
   # create a temporary local ref, make it point to the commit, and do the
   # push
   tmp_b = self.gl_repo.create_branch('gl_tmp_ref', head)
   try:
     git.push(self.name, '{0}:{1}'.format(tmp_b, name))
     return self.lookup_branch(name)
   except ErrorReturnCode as e:
     raise GlError(stderr(e))
   finally:
     tmp_b.delete()
Пример #29
0
 def create_tag(self, name, commit):
   if self.lookup_tag(name):
     raise GlError(
         'Tag {0} already exists in remote repository {1}'.format(
             name, self.name))
   # We can't create a tag in a remote without creating a local one first. So
   # we create a temporary local ref, make it point to the commit, and do the
   # push
   tmp_t = self.gl_repo.create_tag('gl_tmp_ref', commit)
   try:
     git.push(self.name, 'refs/tags/{0}:refs/tags/{1}'.format(tmp_t, name))
     return self.lookup_tag(name)
   except ErrorReturnCode as e:
     raise GlError(stderr(e))
   finally:
     tmp_t.delete()
Пример #30
0
Файл: git.py Проект: kball/ambry
    def push(self, username="******", password="******"):
        '''Push to  remote'''

        def line_proc(line,stdin):

            if "Username for" in line:
                stdin.put(username+ "\n")
                
            elif "Password for" in line:
                stdin.put(password+ "\n")

            else:
                print "git-push: ", line.strip()

        rcv = self.char_to_line(line_proc)

        
        try:
            # This is a super hack. See http://amoffat.github.io/sh/tutorials/2-interacting_with_processes.html
            # for some explaination. 
            p =  git.push('-u','origin','master',  _out=rcv,  _out_bufsize=0, _tty_in=True)
            p.exit_code
        except ErrorReturnCode_128:
            raise Exception("""Push to repository repository failed. You will need to store or cache credentials. 
            You can do this by using ssh, .netrc, or a credential maanger. 
            See: https://www.kernel.org/pub/software/scm/git/docs/gitcredentials.html""")
            
        return True
Пример #31
0
 def create_tag(self, name, commit):
   if self.lookup_tag(name):
     raise GlError(
         'Tag {0} already exists in remote repository {1}'.format(
             name, self.name))
   # We can't create a tag in a remote without creating a local one first. So
   # we create a temporary local ref, make it point to the commit, and do the
   # push
   tmp_t = self.gl_repo.create_tag('gl_tmp_ref', commit)
   try:
     git.push(self.name, 'refs/tags/{0}:refs/tags/{1}'.format(tmp_t, name))
     return self.lookup_tag(name)
   except ErrorReturnCode as e:
     raise GlError(stderr(e))
   finally:
     tmp_t.delete()
Пример #32
0
def main():
    """Script body"""
    app_dir = join(dirname(abspath(__file__)), '..')
    sys.path.append(app_dir)

    from carto_renderer import version  # pylint: disable=import-error

    cur_version = version.SEMANTIC
    if not cur_version.endswith('-SNAPSHOT'):
        raise ValueError('Not a SNAPSHOT version!')
    default_release = cur_version.replace('-SNAPSHOT', '')

    pytest.main(app_dir)

    release_version = prompt(
        'Release version [{ver}]: '.format(ver=default_release),
        r'^\d+[.]\d+[.]\d+$',
        'Release version should be Major.Minor.Patch!',
        default_release)

    split_version = [int(i) for i in release_version.split('.')]
    split_version[2] += 1
    default_next = '.'.join([str(s) for s in split_version]) + '-SNAPSHOT'

    next_version = prompt(
        'Next version [' + default_next + ']: ',
        r'^\d+[.]\d+[.]\d+-SNAPSHOT$',
        'Not a valid SNAPSHOT version!',
        default_next)

    ver_file = join(app_dir, 'carto_renderer', 'version.py')
    set_version(ver_file, cur_version, release_version)
    git.add(ver_file)

    git.commit('-m', 'Setting version to ' + release_version)
    git.tag('v' + release_version)

    set_version(ver_file, release_version, next_version)
    git.add(ver_file)
    git.commit('-m' 'Setting version to ' + next_version)

    do_push = prompt('Push changes to the remote repository (y/n)? [y]: ',
                     '.*', None, 'y')

    if do_push.lower().startswith('y'):
        print(git.push())
        print(git.push('--tags'))
Пример #33
0
def log(msg):
    global f
    print('[logbot]', 'log:', msg)
    today = strftime('%Y-%m-%d.log')
    if f.name != today:
        f.close()
        try:
            git.add(f.name)
            git.commit('-m', 'add ' + f.name)
            git.push()
        except ErrorReturnCode:
            print('[logbot]', 'err:', 'fail to commit', f.name)

        print('[logbot]', 'commit:', f.name)
        print('[logbot]', 'new:', today)
        f = open(today, 'w+')
    f.write(msg)
Пример #34
0
def migrate_repo(packagepath, destination_path, use_https, authors="~/ros/fuerte/tue/authors.txt"):
    """#The process to migrate a project is:
    # Create a new repository.
    $ git svn clone <svn_url> <destination_path>
    $ cd ~/ros/fuerte/tue/git/challenge_cleanup
    $ git remote add origin <repo https url>
    $ git pull origin master
    $ git push origin master"""

    authors = os.path.expanduser(authors)

    svn_url = svnurl_for_path(packagepath)
    language, name, description = get_package_info(packagepath)

    try:
        repo = create_repo(name, description, language=language)
        print "URLs: ".format(repo.clone_url, repo.ssh_url)
    except github.GithubException as e:
        if e.status == 422:
            cont = raw_input(
                "The repo has an invalid field, it could already exist. Please verify and press 'c' to continue without first creating the repo: ")
            if 'c' in cont:
                repo = tue.get_repo(name)
            else:
                sys.stderr.write("Could not migrate {0}".format(name))
                return

    print "git svn clone {0} {1} A={2}".format(svn_url, destination_path, authors)
    git.svn.clone(svn_url, destination_path, A=authors)

    cd(destination_path)

    if use_https:
        git_url = repo.clone_url
    else:
        git_url = repo.ssh_url

    print "git remote add origin {0}".format(git_url)
    git.remote.add("origin", git_url)

    print "git pull origin master"
    git.pull("origin", "master")

    print "git push origin master"
    git.push("origin", "master")
Пример #35
0
    def push(self):
        '''Push to  remote'''

        if not self.remote_url:
            raise RepositoryException("Can't push without setting remote_url in constructor")

        p =  git.push(self.remote_url)

        return True
Пример #36
0
def deploy_code(repo):
    logging.info("Deploying repo: %s, back2github: %s", repo["dir"], repo["sync"])
    try:
        logging.info("Change working directory to %s", repo["dir"])
        sh.cd(repo["dir"])
        logging.info("Update code, git pull origin")
        git.pull("origin", _out=logging.info, _err=logging.error)
        logging.info("done")
        logging.info("Delete old branches, git fetch -p")
        git.fetch("origin", "-p", _out=logging.info, _err=logging.error)
        logging.info("done")

        if repo["sync"]:
            logging.info("Back2github, git push github")
            git.push("github", _out=logging.info, _err=logging.error, _bg=True)

    except Exception as e:
        logging.info("Deploy error: %s", e)
def main():
    """Script body"""
    app_dir = join(dirname(abspath(__file__)), '..')
    sys.path.append(app_dir)

    from carto_renderer import version  # pylint: disable=import-error

    cur_version = version.SEMANTIC
    if not cur_version.endswith('-SNAPSHOT'):
        raise ValueError('Not a SNAPSHOT version!')
    default_release = cur_version.replace('-SNAPSHOT', '')

    pytest.main(app_dir)

    release_version = prompt(
        'Release version [{ver}]: '.format(ver=default_release),
        r'^\d+[.]\d+[.]\d+$', 'Release version should be Major.Minor.Patch!',
        default_release)

    split_version = [int(i) for i in release_version.split('.')]
    split_version[2] += 1
    default_next = '.'.join([str(s) for s in split_version]) + '-SNAPSHOT'

    next_version = prompt('Next version [' + default_next + ']: ',
                          r'^\d+[.]\d+[.]\d+-SNAPSHOT$',
                          'Not a valid SNAPSHOT version!', default_next)

    ver_file = join(app_dir, 'carto_renderer', 'version.py')
    set_version(ver_file, cur_version, release_version)
    git.add(ver_file)

    git.commit('-m', 'Setting version to ' + release_version)
    git.tag('v' + release_version)

    set_version(ver_file, release_version, next_version)
    git.add(ver_file)
    git.commit('-m' 'Setting version to ' + next_version)

    do_push = prompt('Push changes to the remote repository (y/n)? [y]: ',
                     '.*', None, 'y')

    if do_push.lower().startswith('y'):
        print(git.push())
        print(git.push('--tags'))
Пример #38
0
def backup():
    access_token = request.form["access_token"]
    spreadsheet_id = request.form["spreadsheet_id"]

    with cd("repo/"):
        git.pull()

        ods = export_as_ods(access_token, spreadsheet_id)
        ods_path = write_bytes_to_file("clubs.ods", ods)
        fods_path = convert_ods_to_fods(ods_path)
        os.remove(ods_path)

        # Only commit and push if any files have changed.
        if git("ls-files", "-m"):
            git.add(fods_path)
            git.commit("-m", "Update spreadsheet.")
            git.push()

    return "Consider it done!"
Пример #39
0
    def process_cookbook(self):
        if not self.cookbook_name:
            sys.stderr.write('Could not find cookbook name, exiting\n')
            sys.exit(1)

        commits = [self.process_cookbook_submodule(self.cookbook_name,
                                                   self.submodule_path,
                                                   self.cookbook_git_url,
                                                   self.COOKBOOK)]

        for dependency in self.dependency_cookbooks:
            dep_path = 'cookbooks/%s' % dependency
            dep_url = self.dependency_cookbooks[dependency]['url']
            commits.append(self.process_cookbook_submodule(dependency,
                                                           dep_path,
                                                           dep_url,
                                                           self.DEPENDENCY))
        # Push any changes
        if any(commits):
            git.push('origin', 'master')
Пример #40
0
    def needs_push(self):
        import os

        try:
            for line in git.push('origin', 'master', n=True, porcelain=True):
                if '[up to date]' in line:
                    return False

            return True

        except ErrorReturnCode_128:
            global_logger.error("Needs_push failed in {}".format(os.getcwd()))
            return False
Пример #41
0
Файл: git.py Проект: kball/ambry
 def needs_push(self):
     import os
     
     try:
         for line in git.push('origin','master',n=True, porcelain=True):
             if '[up to date]' in line:
                 return False
 
         return True
         
     except ErrorReturnCode_128:
         logger.error("Needs_push failed in {}".format(os.getcwd()))
         return False
Пример #42
0
    def __del__(self):
        cd(self.repo)

        newname = self.fname.split('-')[0]
        logging.info('Copying file %s to %s' % (self.fname, newname))
        copyfile(self.directory + '/' + self.fname, self.repo + '/' + newname)

        try:
            logging.info('Adding the file to git')
            git.add(newname)

            logging.info('Committing the file')
            git.commit('-m', 'changes to ' + newname)

            logging.info('Pushing ...')
            git.push()

        except:
            pass

        if self._f and not self._f.closed:
            self._f.close()
Пример #43
0
    def handle(self, *args, **options):
        for group in DeviceGroup.objects.all():
            if group.repository is None:
                continue

            repo_path, group_path = os.path.split(group.config_backup_path)
            archive_path = os.path.join(repo_path, "_Archive", group_path)

            if not os.path.exists(group.config_backup_path):
                self.stderr.write("Invalid path: %s" %
                                  group.config_backup_path)
                continue

            group.repository.lock.acquire()

            if not os.path.exists(archive_path):
                os.makedirs(archive_path)

            os.chdir(group.config_backup_path)

            for filename in os.listdir("."):
                label = os.path.splitext(filename)[0]
                try:
                    Device.objects.get(label=label)
                except Device.DoesNotExist:
                    self.stdout.write("Archiving: %s" % label)
                    os.rename(filename, os.path.join(archive_path, filename))

            os.chdir(group.repository.path)

            git.add("-A", ".")

            if NetworkDeviceConfigBackupHandler._git_commit(
                    "Moving device configs to archive"):
                git.push()

            group.repository.lock.release()
Пример #44
0
    def push(self, remote, env={}, branch=None):
        """
        Push a branch to a given remote

        Given a remote, env and branch, push branch
        to remote and add the environment variables
        in the env dict to the environment of the
        "git push" command.

        If no branch is given, the current branch
        will be used.

        The ability to specify env is so that PKEY
        and GIT_SSH can be specified so Git can use
        different SSH credentials than the current
        user (i.e. deploy keys for Github). If PKEY
        is not defined, the environment will not be
        over-ridden.

        """
        os.chdir(self.repo)

        if branch:
            branch_to_push = branch
        else:
            branch_to_push = self.current_branch()

        # if there is no PKEY, we don't need to override env
        # We are explicit about what we are pushing, since the default behavior
        # is different in different versions of Git and/or by configuration
        if env["PKEY"]:
            new_env = os.environ.copy()
            new_env.update(env)
            git.push(remote, branch_to_push, _env=new_env)
        else:
            git.push(remote, branch_to_push)
Пример #45
0
    def push(self, remote, env={}, branch=None):
        """
        Push a branch to a given remote

        Given a remote, env and branch, push branch
        to remote and add the environment variables
        in the env dict to the environment of the
        "git push" command.

        If no branch is given, the current branch
        will be used.

        The ability to specify env is so that PKEY
        and GIT_SSH can be specified so Git can use
        different SSH credentials than the current
        user (i.e. deploy keys for Github). If PKEY
        is not defined, the environment will not be
        over-ridden.

        """
        os.chdir(self.repo)

        if branch:
            branch_to_push = branch
        else:
            branch_to_push = self.current_branch()

        # if there is no PKEY, we don't need to override env
        # We are explicit about what we are pushing, since the default behavior
        # is different in different versions of Git and/or by configuration
        if env["PKEY"]:
            new_env = os.environ.copy()
            new_env.update(env)
            git.push(remote, branch_to_push, _env=new_env)
        else:
            git.push(remote, branch_to_push)
Пример #46
0
def push_for_teams(teams, repo):
    for team in teams:
        print("\t Pushing changes for team {}".format(team))
        team_repo_name = "{repo}-{batch}-{group}-{team}".format(
            repo=repo, batch=BATCH, group=GROUP, team=team)
        team_repo_git_url = "[email protected]:{org}/{repo}.git".format(
            org=TEAM_ORGANIZATION, repo=team_repo_name)

        with sh.pushd(repo):
            git.remote.add(team_repo_name, team_repo_git_url)
            try:
                out = git.push(team_repo_name, 'master')
                print(out.stdout or out.stderr)
            except ErrorReturnCode as e:
                pass
            finally:
                git.remote.remove(team_repo_name)
Пример #47
0
    def needs_push(self):
        import os

        if not self.remote_url:
            raise RepositoryException("Can't push without setting remote_url in constructor")

        try:

            for line in git.push(self.remote_url,n=True, porcelain=True):
                if '[up to date]' in line:
                    return False

            return True

        except ErrorReturnCode_128:
            global_logger.error("Needs_push failed in {}".format(os.getcwd()))
            return False
Пример #48
0
    def publish(self, branch):
        self._check_op_not_in_progress()

        if not isinstance(branch, RemoteBranch):  # TODO: allow this
            raise GlError(
                'Can\'t publish to a local branch (yet---this will be implemented in '
                'the future)')

        try:
            assert self.branch_name.strip()
            assert branch.branch_name in self.gl_repo.remotes[
                branch.remote_name].listall_branches()

            cmd = git.push(
                branch.remote_name, '{0}:{1}'.format(self.branch_name,
                                                     branch.branch_name))
            if 'Everything up-to-date' in stderr(cmd):
                raise GlError('No commits to publish')
        except ErrorReturnCode as e:
            err_msg = stderr(e)
            if 'Updates were rejected' in err_msg:
                raise GlError('There are changes you need to fuse/merge')
            raise GlError(err_msg)
Пример #49
0
  def publish(self, branch):
    self._check_op_not_in_progress()

    if not isinstance(branch, RemoteBranch):  # TODO: allow this
      raise GlError(
          'Can\'t publish to a local branch (yet---this will be implemented in '
          'the future)')

    try:
      assert self.branch_name.strip()
      assert branch.branch_name in self.gl_repo.remotes[
          branch.remote_name].listall_branches()

      cmd = git.push(
          branch.remote_name,
          '{0}:{1}'.format(self.branch_name, branch.branch_name))
      if 'Everything up-to-date' in stderr(cmd):
        raise GlError('No commits to publish')
    except ErrorReturnCode as e:
      err_msg = stderr(e)
      if 'Updates were rejected' in err_msg:
        raise GlError('There are changes you need to fuse/merge')
      raise GlError(err_msg)
Пример #50
0
 def delete(self):
     try:
         git.push(self.remote_name, ':{0}'.format(self.branch_name))
     except ErrorReturnCode as e:
         raise GlError(stderr(e))
Пример #51
0
def git_push(remote, branch, file_path):
    '''Push changes to remote'''
    p = git.push(remote, branch, _cwd=dir_path(file_path), _tty_out=False)
    p.wait()
    show_msg('Push Done', 'Info')
Пример #52
0
 def delete(self):
   try:
     git.push(self.remote_name, ':{0}'.format(self.branch_name))
   except ErrorReturnCode as e:
     raise GlError(stderr(e))
Пример #53
0
    commit = input(
        'Changes were detected, would you like to commit all current changes? (y/n) '
    )
    if commit != 'y' and commit != 'n':
        print('Expected "y" or "n", instead found {}. Exiting.'.format(commit))
        exit(1)
    elif commit == 'n':
        print(
            'Not committing changes; please commit all changes and try again. Exiting.'
        )
        print(status)
        exit(2)
    commit_msg = input('Committing, please provide a commit message: ')
    git.add('.')
    git.commit('-am', commit_msg)
    push_result = git.push()
    print(push_result)

if 'Your branch is ahead of' in status:
    print('Found unpushed commits. Pushing...')
    push_result = git.push()
    print(push_result)
clean()
make_dist()

upld = input(
    'About to upload to PyPi, are you sure you want to do this? (y/n) ')
if upld != 'y' and upld != 'n':
    print('Expected "y" or "n", instead found {}. Exiting.'.format(upld))
    exit(1)
if upld == 'n':
Пример #54
0
    def install_app(self, appid, pdpobject):
        print "Analyzing artifacts.."
        plan = pdpobject.plan

        for a in plan.artifacts:
            h, c = self.handler_map.get(a.type)
            if h is None:
                raise NotImplementedError("No handler for artifact type : %s" % a.type)
            print "Detected app type : %s, Matching cartridge : %s" % (a.type, c)
            ho = h(pdpobject, a)
            renv = ho.handle_artifact()

            print "Creating application.."
            r = self._create_app(appid, h.cartridge)
            if r.ok:
                print "Application %s created" % appid
            else:
                print "Error creating application %s" % appid
                print r.status_code, r.text
                return

            # Set env variables on the app using rhc for now
            from sh import rhc
            for k, v in renv.items():
                rhc.env.set("%s=%s" % (k, v), "-a", appid)
                print "Set environment %s=%s on the app" % (k, v)

            resp = r.json()
            print "Received response : %s" % resp
            data = resp["data"]
            # Start staging it.
            git_url = data["git_url"]
            web_url = data["app_url"]

            print "Staging PDP archive.."
            print "PDP archive is at : %s" % pdpobject.pdpdir
            print "Configuring git.."

            # Empty out any samples given by the cartridge
            from sh import git
            import sh
            import tempfile
            import shutil
            import subprocess
            tmpdir = tempfile.mkdtemp()
            subprocess.check_call(["git", "clone", git_url, tmpdir])
            print "Cloned cartridge sample to %s" % tmpdir
            cwd = os.getcwd()
            os.chdir(tmpdir)
            git.rm("-r", "*")
            print "Removed all contents from cartridge repo"

            # Copy pdpdir contents
            subprocess.check_call("cp -rp %s/* ." % pdpobject.pdpdir, shell=True)
            print "Copied app contents to %s" % tmpdir
            sh.ls("-la", tmpdir)
            print "Adding and committing app code"
            git.add("*")
            git.commit("-m", "Adding app contents")

            print "Configuring git remote.."
            git.remote.add("rhc", git_url)

            print "Pushing to openshift"
            git.push("-u", "-f", "rhc", "master")

            print "Uploaded app successfully.."
            print "App is available at : %s" % web_url

            return appid, git_url, web_url
Пример #55
0
    def run_completed(cls):
        """
        Many things happen once run is complete. At this point, all of the
        device configs are already committed.

        * Each device is symlinked in the `ByHostname` directory and symlinks
          for deleted device are removed.

        * All repositories are pushed to the default remote.

        * All device type regex filters are committed to the repository
          with the ID 1. This is done in order to track changes to the filters.

        """

        super(NetworkDeviceConfigBackupHandler, cls).run_completed()

        # Generate "ByHostname" symlinks

        for repository in Repository.objects.all():
            repository.lock.acquire()

        for device in Device.objects.all():
            if device.group.repository:
                symlink_dir = os.path.join(device.group.repository.path,
                                           "_ByHostname")
                if not os.path.exists(symlink_dir):
                    os.mkdir(symlink_dir)
                symlink = os.path.join(symlink_dir,
                                       '{}.txt'.format(device.hostname))
                if not os.path.islink(symlink) and os.path.exists(
                        device.config_backup_filename):
                    os.symlink(
                        os.path.relpath(device.config_backup_filename,
                                        symlink_dir), symlink)

        # Git push and config filter commits

        if settings.TASK_CONFIG_BACKUP_DISABLE_GIT:
            for repository in Repository.objects.all():
                repository.lock.release()
            return

        for repository in Repository.objects.all():
            os.chdir(repository.path)
            # Clean up broken symlinks
            find('-L', '_ByHostname', '-type', 'l', '-delete')
            git.add('-A', '_ByHostname')
            if cls._git_commit('Symlink updates'):
                git.push()

        for device_group in DeviceGroup.objects.all():
            if device_group.repository:
                os.chdir(device_group.repository.path)
                git.push()

        # TODO: make the repository ID configurable

        os.chdir(Repository.objects.get(id=1).path)

        for device_type in DeviceType.objects.all():
            if not device_type.config_filter:
                continue
            filename = os.path.join(
                Repository.objects.get(id=1).path, 'Meta',
                "{}_filter.txt".format(
                    RE_MATCH_FIRST_WORD.findall(
                        device_type.name.replace(" ", "_"))[0]))

            with codecs.open(filename, 'w', 'utf8') as f:
                f.write("# Automatically generated from database\n\n")
                f.write(device_type.config_filter)

            git.add("--", quote(filename))
            if cls._git_commit('Config filter for device type "%s" changed' %
                               device_type.name):
                git.push()

        for repository in Repository.objects.all():
            repository.lock.release()
Пример #56
0
 def git_push(self):
     """Push current version to git."""
     # switch to project folder
     cd(self.paths['root'])
     # push changes to remote
     print git.push('origin')
Пример #57
0
print("load changes")
git.pull("--all")
git.reset("origin/master", "--hard")
git.pull()

print("Finish download")
for i in l.split("\n")[1:]:
    if i and regex.search(i):
        ips.append(regex.search(i).groups()[0])


with open("rawlist.txt", "w") as fp:
    for i in ips:
        fp.write(i+"\n")

with open("list.txt", 'w') as fp:
    # s = "[AutoProxy 0.2.9]\n"
    for i in ips:
        fp.write("||{}\n".format(i))
    # s = base64.b64encode(s.encode('utf8')).decode()
    # for i in range(0, len(s), 64):
        # fp.write(s[i:i+64])
        # fp.write("\n")

if git.status("--short") != "":
    print("updating")
    git.add(".")
    git.commit("-m", "update by robot")
    git.push()
    print("updating finished")
Пример #58
0
print("load changes")
git.pull("--all")
git.reset("origin/master", "--hard")
git.pull()

print("Finish download")
for i in l.split("\n")[1:]:
    if i and regex.search(i):
        ips.append(regex.search(i).groups()[0])

with open("rawlist.txt", "w") as fp:
    for i in ips:
        fp.write(i + "\n")

with open("list.txt", 'w') as fp:
    # s = "[AutoProxy 0.2.9]\n"
    for i in ips:
        fp.write("||{}\n".format(i))
    # s = base64.b64encode(s.encode('utf8')).decode()
    # for i in range(0, len(s), 64):
    # fp.write(s[i:i+64])
    # fp.write("\n")

if git.status("--short") != "":
    print("updating")
    git.add(".")
    git.commit("-m", "update by robot")
    git.push()
    print("updating finished")
        exit()

time_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S %z')

try:
    git.checkout('gh-pages')

    for dir_name in dir_names:
        # Remove the current documentation folders (v4, v5, current)
        try:
            rmtree(dir_name)
        except:
            pass
        # Move generated folders (in 'tmp/') into the root folder
        move('tmp/' + dir_name, '.')

    # Remove 'tmp/'
    rmtree('tmp')
except:
    raise

if args.commit or args.push_gh_pages:
    # Commit new version
    git.add(dir_names)
    git.commit(m='Auto-generated docs %s' % time_str)

if args.push_gh_pages:
    # Commit new version
    print 'Pushing to "%s"' % args.push_gh_pages
    git.push([args.push_gh_pages, 'gh-pages'])
Пример #60
0
    def add_to_blacklist(**kwargs):
        if 'windows' in str(platform.platform()).lower():
            log('warning', "Git support not available in Windows.")
            return (False, "Git support not available in Windows.")

        blacklist = kwargs.get("blacklist", "")
        item_to_blacklist = kwargs.get("item_to_blacklist", "")
        username = kwargs.get("username", "")
        chat_profile_link = kwargs.get("chat_profile_link", "http://chat.stackexchange.com/users")
        code_permissions = kwargs.get("code_permissions", False)

        # Make sure git credentials are set up
        if git.config("--global", "--get", "user.name", _ok_code=[0, 1]) == "":
            return (False, "Tell someone to run `git config --global user.name \"SmokeDetector\"`")

        if git.config("--global", "--get", "user.email", _ok_code=[0, 1]) == "":
            return (False, "Tell someone to run `git config --global user.email \"[email protected]\"`")

        if blacklist == "":
            # If we broke the code, and this isn't assigned, error out before doing anything, but do
            # so gracefully with a nice error message.
            return (False, "Programming Error - Critical information missing for GitManager: blacklist")

        if item_to_blacklist == "":
            # If we broke the code, and this isn't assigned, error out before doing anything, but do
            # so gracefully with a nice error message.
            return (False, "Programming Error - Critical information missing for GitManager: item_to_blacklist")

        item_to_blacklist = item_to_blacklist.replace("\s", " ")

        if blacklist == "website":
            blacklist_file_name = "blacklisted_websites.txt"
            ms_search_option = "&body_is_regex=1&body="
        elif blacklist == "keyword":
            blacklist_file_name = "bad_keywords.txt"
            ms_search_option = "&body_is_regex=1&body="
        elif blacklist == "username":
            blacklist_file_name = "blacklisted_usernames.txt"
            ms_search_option = "&username_is_regex=1&username="******"Invalid blacklist type specified, something has broken badly!")

        git.checkout("master")
        try:
            git.pull()
        except:
            pass

        # Check that we're up-to-date with origin (GitHub)
        git.remote.update()
        if git("rev-parse", "refs/remotes/origin/master").strip() != git("rev-parse", "master").strip():
            return (False, "HEAD isn't at tip of origin's master branch")

        # Check that blacklisted_websites.txt isn't modified locally. That could get ugly fast
        if blacklist_file_name in git.status():  # Also ugly
            return (False, "{0} is modified locally. This is probably bad.".format(blacklist_file_name))

        # Add item to file
        with open(blacklist_file_name, "a+") as blacklist_file:
            last_character = blacklist_file.read()[-1:]
            if last_character != "\n":
                blacklist_file.write("\n")
            blacklist_file.write(item_to_blacklist + "\n")

        # Checkout a new branch (for PRs for non-code-privileged people)
        branch = "auto-blacklist-{0}".format(str(time.time()))
        git.checkout("-b", branch)

        # Clear HEAD just in case
        git.reset("HEAD")

        git.add(blacklist_file_name)
        git.commit("--author='SmokeDetector <*****@*****.**>'",
                   "-m", u"Auto blacklist of {0} by {1} --autopull".format(item_to_blacklist, username))

        if code_permissions:
            git.checkout("master")
            git.merge(branch)
            git.push("origin", "master")
            git.branch('-D', branch)  # Delete the branch in the local git tree since we're done with it.
        else:
            git.push("origin", branch)
            git.checkout("master")

            if GlobalVars.github_username is None or GlobalVars.github_password is None:
                return (False, "Tell someone to set a GH password")

            payload = {"title": u"{0}: Blacklist {1}".format(username, item_to_blacklist),
                       "body": u"[{0}]({1}) requests the blacklist of the {2} {3}. See the Metasmoke search [here]"
                               "(https://metasmoke.erwaysoftware.com/search?utf8=%E2%9C%93{4}{5})\n"
                               u"<!-- METASMOKE-BLACKLIST-{6} {3} -->".format(username, chat_profile_link, blacklist,
                                                                              item_to_blacklist, ms_search_option,
                                                                              item_to_blacklist.replace(" ", "+"),
                                                                              blacklist.upper()),
                       "head": branch,
                       "base": "master"}
            response = requests.post("https://api.github.com/repos/Charcoal-SE/SmokeDetector/pulls",
                                     auth=HTTPBasicAuth(GlobalVars.github_username, GlobalVars.github_password),
                                     data=json.dumps(payload))
            log('debug', response.json())
            try:
                git.checkout("deploy")  # Return to deploy, pending the accept of the PR in Master.
                git.branch('-D', branch)  # Delete the branch in the local git tree since we're done with it.
                return (True, "You don't have code privileges, but I've [created a pull request for you]({0}).".format(
                    response.json()["html_url"]))
            except KeyError:
                git.checkout("deploy")  # Return to deploy

                # Delete the branch in the local git tree, we'll create it again if the
                # command is run again. This way, we keep things a little more clean in
                # the local git tree
                git.branch('-D', branch)

                # Error capture/checking for any "invalid" GH reply without an 'html_url' item,
                # which will throw a KeyError.
                if "bad credentials" in str(response.json()['message']).lower():
                    # Capture the case when GH credentials are bad or invalid
                    return (False, "Something is wrong with the GH credentials, tell someone to check them.")
                else:
                    # Capture any other invalid response cases.
                    return (False, "A bad or invalid reply was received from GH, the message was: %s" %
                            response.json()['message'])

        git.checkout("deploy")  # Return to deploy to await CI.

        return (True, "Blacklisted {0}".format(item_to_blacklist))