예제 #1
0
def main():
    args = parse_args()

    if not dist_newer_than_head():
        run_python_script('create-dist.py')

    build_version = get_electron_build_version()
    if not ELECTRON_VERSION.startswith(build_version):
        error = 'Tag name ({0}) should match build version ({1})\n'.format(
            ELECTRON_VERSION, build_version)
        sys.stderr.write(error)
        sys.stderr.flush()
        return 1

    github = GitHub(auth_token())
    releases = github.repos(ELECTRON_REPO).releases.get()
    tag_exists = False
    for r in releases:
        if not r['draft'] and r['tag_name'] == args.version:
            release = r
            tag_exists = True
            break

    assert tag_exists == args.overwrite, \
           'You have to pass --overwrite to overwrite a published release'

    if not args.overwrite:
        release = create_or_get_release_draft(github, releases, args.version,
                                              tag_exists)

    # Upload Electron with GitHub Releases API.
    upload_electron(github, release, os.path.join(DIST_DIR, DIST_NAME))
    upload_electron(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME))
    if PLATFORM == 'darwin':
        upload_electron(github, release,
                        os.path.join(DIST_DIR, 'electron-api.json'))
        upload_electron(github, release, os.path.join(DIST_DIR,
                                                      'electron.d.ts'))
        upload_electron(github, release, os.path.join(DIST_DIR, DSYM_NAME))
    elif PLATFORM == 'win32':
        upload_electron(github, release, os.path.join(DIST_DIR, PDB_NAME))

    # Upload free version of ffmpeg.
    ffmpeg = get_zip_name('ffmpeg', ELECTRON_VERSION)
    upload_electron(github, release, os.path.join(DIST_DIR, ffmpeg))

    # Upload chromedriver and mksnapshot for minor version update.
    if parse_version(args.version)[2] == '0':
        chromedriver = get_zip_name('chromedriver', ELECTRON_VERSION)
        upload_electron(github, release, os.path.join(DIST_DIR, chromedriver))
        mksnapshot = get_zip_name('mksnapshot', ELECTRON_VERSION)
        upload_electron(github, release, os.path.join(DIST_DIR, mksnapshot))

    if PLATFORM == 'win32' and not tag_exists:
        # Upload PDBs to Windows symbol server.
        run_python_script('upload-windows-pdb.py')

        # Upload node headers.
        run_python_script('create-node-headers.py', '-v', args.version)
        run_python_script('upload-node-headers.py', '-v', args.version)
예제 #2
0
파일: upload.py 프로젝트: brave/electron
def main():
  args = parse_args()

  if not args.publish_release:
    build_version = get_electron_build_version()
    if not get_electron_version().startswith(build_version):
      error = 'Tag name ({0}) should match build version ({1})\n'.format(
          get_electron_version(), build_version)
      sys.stderr.write(error)
      sys.stderr.flush()
      return 1

  github = GitHub(auth_token())
  releases = github.repos(ELECTRON_REPO).releases.get()
  tag_exists = False
  for release in releases:
    if not release['draft'] and release['tag_name'] == args.version:
      tag_exists = True
      break

  release = create_or_get_release_draft(github, releases, args.version,
                                        tag_exists)

  if args.publish_release:
    # Upload the Node SHASUMS*.txt.
    run_python_script('upload-node-checksums.py', '-v', get_electron_version(), '--dist-url', args.dist_url)

    # Upload the index.json.
    # run_python_script('upload-index-json.py')

    # Create and upload the Electron SHASUMS*.txt
    release_electron_checksums(github, release)

    # Press the publish button.
    # publish_release(github, release['id'])

    # Do not upload other files when passed "-p".
    return

  # Upload Electron with GitHub Releases API.
  upload_electron(github, release, os.path.join(dist_dir(), DIST_NAME))
  # upload_electron(github, release, os.path.join(dist_dir(), SYMBOLS_NAME))
  # if PLATFORM == 'darwin':
  #   upload_electron(github, release, os.path.join(dist_dir(), DSYM_NAME))
  # elif PLATFORM == 'win32':
  #   upload_electron(github, release, os.path.join(dist_dir(), PDB_NAME))

  # Upload chromedriver and mksnapshot.
  chromedriver = get_zip_name('chromedriver', get_chromedriver_version())
  upload_electron(github, release, os.path.join(dist_dir(), chromedriver))
    # mksnapshot = get_zip_name('mksnapshot', get_electron_version())
    # upload_electron(github, release, os.path.join(dist_dir(), mksnapshot))

  # if PLATFORM == 'win32' and not tag_exists:
  #   # Upload PDBs to Windows symbol server.
  #   run_python_script('upload-windows-pdb.py')

  # Upload node headers.
  run_python_script('upload-node-headers.py', '-v', args.version)
예제 #3
0
def main():
  args = parse_args()

  if not args.publish_release:
    build_version = get_electron_build_version()
    if not get_electron_version().startswith(build_version):
      error = 'Tag name ({0}) should match build version ({1})\n'.format(
          get_electron_version(), build_version)
      sys.stderr.write(error)
      sys.stderr.flush()
      return 1

  github = GitHub(auth_token())
  releases = github.repos(ELECTRON_REPO).releases.get()
  tag_exists = False
  for release in releases:
    if not release['draft'] and release['tag_name'] == args.version:
      tag_exists = True
      break

  release = create_or_get_release_draft(github, releases, args.version,
                                        tag_exists)

  if args.publish_release:
    # Upload the Node SHASUMS*.txt.
    run_python_script('upload-node-checksums.py', '-v', get_electron_version(), '--dist-url', args.dist_url)

    # Upload the index.json.
    # run_python_script('upload-index-json.py')

    # Create and upload the Electron SHASUMS*.txt
    release_electron_checksums(github, release)

    # Press the publish button.
    # publish_release(github, release['id'])

    # Do not upload other files when passed "-p".
    return

  # Upload Electron with GitHub Releases API.
  upload_electron(github, release, os.path.join(dist_dir(), DIST_NAME))
  upload_electron(github, release, os.path.join(dist_dir(), SYMBOLS_NAME))
  # if PLATFORM == 'darwin':
  #   upload_electron(github, release, os.path.join(dist_dir(), DSYM_NAME))
  # elif PLATFORM == 'win32':
  #   upload_electron(github, release, os.path.join(dist_dir(), PDB_NAME))

  # Upload chromedriver and mksnapshot.
  chromedriver = get_zip_name('chromedriver', get_chromedriver_version())
  upload_electron(github, release, os.path.join(dist_dir(), chromedriver))
  # mksnapshot = get_zip_name('mksnapshot', get_electron_version())
  # upload_electron(github, release, os.path.join(dist_dir(), mksnapshot))

  # if PLATFORM == 'win32' and not tag_exists:
  #   # Upload PDBs to Windows symbol server.
  #   run_python_script('upload-windows-pdb.py')

  # Upload node headers.
  run_python_script('upload-node-headers.py', '-v', args.version)
예제 #4
0
파일: upload.py 프로젝트: nekuz0r/electron
def main():
  args = parse_args()

  if not args.publish_release:
    if not dist_newer_than_head():
      create_dist = os.path.join(SOURCE_ROOT, 'script', 'create-dist.py')
      execute([sys.executable, create_dist])

    build_version = get_atom_shell_build_version()
    if not ATOM_SHELL_VERSION.startswith(build_version):
      error = 'Tag name ({0}) should match build version ({1})\n'.format(
          ATOM_SHELL_VERSION, build_version)
      sys.stderr.write(error)
      sys.stderr.flush()
      return 1

  github = GitHub(auth_token())
  releases = github.repos(ATOM_SHELL_REPO).releases.get()
  tag_exists = False
  for release in releases:
    if not release['draft'] and release['tag_name'] == args.version:
      tag_exists = True
      break

  release = create_or_get_release_draft(github, releases, args.version,
                                        tag_exists)

  if args.publish_release:
    # Upload the SHASUMS.txt.
    execute([sys.executable,
             os.path.join(SOURCE_ROOT, 'script', 'upload-checksums.py'),
             '-v', ATOM_SHELL_VERSION])

    # Upload the index.json.
    execute([sys.executable,
             os.path.join(SOURCE_ROOT, 'script', 'upload-index-json.py')])

    # Press the publish button.
    publish_release(github, release['id'])

    # Do not upload other files when passed "-p".
    return

  # Upload atom-shell with GitHub Releases API.
  upload_atom_shell(github, release, os.path.join(DIST_DIR, DIST_NAME))
  upload_atom_shell(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME))

  # Upload chromedriver and mksnapshot for minor version update.
  if parse_version(args.version)[2] == '0':
    chromedriver = 'chromedriver-{0}-{1}-{2}.zip'.format(
        get_chromedriver_version(), get_platform_key(), get_target_arch())
    upload_atom_shell(github, release, os.path.join(DIST_DIR, chromedriver))
    upload_atom_shell(github, release, os.path.join(DIST_DIR, MKSNAPSHOT_NAME))

  if PLATFORM == 'win32' and not tag_exists:
    # Upload node headers.
    execute([sys.executable,
             os.path.join(SOURCE_ROOT, 'script', 'upload-node-headers.py'),
             '-v', args.version])
예제 #5
0
def main():
    github = GitHub(auth_token())
    releases = github.repos(BROWSER_LAPTOP_REPO).releases.get()
    tag = 'v' + json.load(open('package.json'))['version']
    tag_exists = False
    for release in releases:
        if not release['draft'] and release['tag_name'] == tag:
            tag_exists = True
            break
    release = create_or_get_release_draft(github, releases, tag, tag_exists)
    for f in get_files_to_upload():
        upload_browser_laptop(github, release, f)
예제 #6
0
def main():
  github = GitHub(auth_token())
  releases = github.repos(BROWSER_LAPTOP_REPO).releases.get()
  tag = 'v' + json.load(open('package.json'))['version']
  tag_exists = False
  for release in releases:
    if not release['draft'] and release['tag_name'] == tag:
      tag_exists = True
      break
  release = create_or_get_release_draft(github, releases, tag,
                                        tag_exists)
  for f in get_files_to_upload():
    upload_browser_laptop(github,release, f)
예제 #7
0
def main():
    github = GitHub(auth_token())
    releases = github.repos(BROWSER_LAPTOP_REPO).releases.get()
    tag = ('v' + json.load(open('package.json'))['version'] +
           release_channel())
    tag_exists = False
    for release in releases:
        if not release['draft'] and release['tag_name'] == tag:
            tag_exists = True
            break
    release = create_or_get_release_draft(github, releases, tag, tag_exists)

    # Press the publish button.
    publish_release(github, release['id'])
예제 #8
0
def main():
    args = parse_args()

    github = GitHub(auth_token())
    releases = github.repos(MESON_REPO).releases.get()
    tag_exists = False
    for release in releases:
        if not release['draft'] and release['tag_name'] == args.version:
            tag_exists = True
            break

    release = create_or_get_release_draft(github, releases, args.version,
                                          tag_exists)

    upload_meson(github, release, os.path.join(DIST_DIR, DIST_NAME))
예제 #9
0
def main():
    args = parse_args()

    if not dist_newer_than_head():
        create_dist = os.path.join(SOURCE_ROOT, 'script', 'create-dist.py')
        execute([sys.executable, create_dist])

    build_version = get_atom_shell_build_version()
    if not ATOM_SHELL_VERSION.startswith(build_version):
        error = 'Tag name ({0}) should match build version ({1})\n'.format(
            ATOM_SHELL_VERSION, build_version)
        sys.stderr.write(error)
        sys.stderr.flush()
        return 1

    # Upload atom-shell with GitHub Releases API.
    github = GitHub(auth_token())
    release_id = create_or_get_release_draft(github, args.version)
    upload_atom_shell(github, release_id, os.path.join(DIST_DIR, DIST_NAME))
    upload_atom_shell(github, release_id, os.path.join(DIST_DIR, SYMBOLS_NAME))

    # Upload node's headers to S3.
    bucket, access_key, secret_key = s3_config()
    upload_node(bucket, access_key, secret_key, NODE_VERSION)

    if args.publish_release:
        # Press the publish button.
        publish_release(github, release_id)

        # Upload the SHASUMS.txt.
        execute([
            sys.executable,
            os.path.join(SOURCE_ROOT, 'script', 'upload-checksums.py'), '-v',
            NODE_VERSION
        ])
예제 #10
0
def main():

    args = parse_args()

    if args.debug:
        logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
        logging.debug('prerelease: {}'.format(args.prerelease))

    if not os.environ.get('npm_config_brave_version'):
        message = ('Error: Please set the $npm_config_brave_version'
                   'environment variable')
        exit(message)

    BRAVE_VERSION = os.environ.get('npm_config_brave_version')

    repo = GitHub(get_env_var('GITHUB_TOKEN')).repos(BRAVE_REPO)

    tag = BRAVE_VERSION
    logging.debug("Tag: {}".format(tag))

    # If we are publishing a prerelease, the release can only be in draft mode. If we
    # are publishing a full release, it is allowed to already be a published release.
    if args.prerelease:
        release = get_draft(repo, tag)
    else:
        release = get_release(repo, tag, allow_published_release_updates=True)

    tag_name = release['tag_name']
    logging.debug("release[id]: {}".format(release['id']))

    logging.info("Releasing {}".format(tag_name))
    publish_release(repo, release['id'], tag_name, args.prerelease, logging)
def main():
    """
    Download the brave-browser/CHANGELOG.md file, parse it and
    convert to markdown, then update the release notes for the
    release specified.

    """

    args = parse_args()

    if args.debug:
        logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)

    changelog_url = args.url

    tag = args.tag

    if not re.match(r'^refs/tags/', tag) and not re.match(r'^v', tag):
        logging.error(" Tag prefix must contain {} or {}".format(
            "\"refs/tags/\"", "\"v\""))
        exit(1)

    match = re.match(r'^refs/tags/(.*)$', tag)
    if match:
        tag = match.group(1)

    match = re.match(r'^v(.*)$', tag)
    if match:
        version = match.group(1)

    logging.debug("CHANGELOG_URL: {}".format(changelog_url))
    logging.debug("TAG: {}".format(tag))
    logging.debug("VERSION: {}".format(version))

    changelog_txt = download_from_url(args, logging, changelog_url)

    tag_changelog_txt = render_markdown(changelog_txt, version, logging)

    # BRAVE_REPO is defined in lib/helpers.py
    repo = GitHub(get_env_var('GITHUB_TOKEN')).repos(BRAVE_REPO)
    release = get_release(repo, tag, allow_published_release_updates=True)

    logging.debug("Release body before update: \n\'{}\'".format(
        release['body']))

    logging.info("Merging original release body with changelog")
    new_body = release['body'] + '\n\n### Release Notes' + '\n\n' + \
        tag_changelog_txt
    logging.debug("release body is now: \n\'{}\'".format(new_body))

    data = dict(tag_name=tag, name=release['name'], body=new_body)
    id = release['id']
    logging.debug("Updating release with id: {}".format(id))
    release = retry_func(
        lambda run: repo.releases.__call__(f'{id}').patch(data=data),
        catch=requests.exceptions.ConnectionError,
        retries=3)
    logging.debug("Release body after update: \n\'{}\'".format(
        release['body']))
예제 #12
0
def main():
    repo = GitHub(get_env('GITHUB_TOKEN')).repos(BROWSER_LAPTOP_REPO)

    release = get_draft(repo, get_tag_without_channel())
    commit_tag = get_commit_tag(get_version())

    print("[INFO] Releasing {}".format(release['tag_name']))
    publish_release(repo, release['id'], get_tag(), commit_tag)
예제 #13
0
def main():
    repo = GitHub(get_env_var('GITHUB_TOKEN')).repos(BRAVE_REPO)

    release = get_draft(repo, get_brave_version())
    commit_tag = get_commit_tag(get_raw_version())

    print("[INFO] Releasing {}".format(release['tag_name']))
    publish_release(repo, release['id'], get_tag(), commit_tag)
예제 #14
0
파일: upload.py 프로젝트: treyau21/electron
def main():
    args = parse_args()

    if not dist_newer_than_head():
        create_dist = os.path.join(SOURCE_ROOT, 'script', 'create-dist.py')
        execute([sys.executable, create_dist])

    build_version = get_atom_shell_build_version()
    if not ATOM_SHELL_VERSION.startswith(build_version):
        error = 'Tag name ({0}) should match build version ({1})\n'.format(
            ATOM_SHELL_VERSION, build_version)
        sys.stderr.write(error)
        sys.stderr.flush()
        return 1

    github = GitHub(auth_token())
    release_id = create_or_get_release_draft(github, args.version)

    if args.publish_release:
        # Upload the SHASUMS.txt.
        execute([
            sys.executable,
            os.path.join(SOURCE_ROOT, 'script', 'upload-checksums.py'), '-v',
            ATOM_SHELL_VERSION
        ])

        # Upload the index.json.
        execute([
            sys.executable,
            os.path.join(SOURCE_ROOT, 'script', 'upload-index-json.py')
        ])

        # Press the publish button.
        publish_release(github, release_id)

        # Do not upload other files when passed "-p".
        return

    # Upload atom-shell with GitHub Releases API.
    upload_atom_shell(github, release_id, os.path.join(DIST_DIR, DIST_NAME))
    upload_atom_shell(github, release_id, os.path.join(DIST_DIR, SYMBOLS_NAME))

    # Upload chromedriver and mksnapshot for minor version update.
    if parse_version(args.version)[2] == '0':
        upload_atom_shell(github, release_id,
                          os.path.join(DIST_DIR, CHROMEDRIVER_NAME))
        upload_atom_shell(github, release_id,
                          os.path.join(DIST_DIR, MKSNAPSHOT_NAME))

    if PLATFORM == 'win32':
        # Upload node headers.
        execute([
            sys.executable,
            os.path.join(SOURCE_ROOT, 'script', 'upload-node-headers.py'),
            '-v', ATOM_SHELL_VERSION
        ])
예제 #15
0
def download_linux_pkgs_from_github(args, logging):

    file_list = []

    # BRAVE_REPO defined in helpers.py
    repo = GitHub(args.github_token).repos(BRAVE_REPO)
    tag_name = args.tag
    release = {}
    releases = get_releases_by_tag(repo, tag_name, include_drafts=True)
    if releases:
        if len(releases) > 1:
            exit("Error: More than 1 release exists with the tag: \'{}\'".
                 format(tag_name))
        release = releases[0]
    if release['assets'] is None:
        logging.error(
            'Error: Could not find GitHub release with tag {}. Exiting...'.
            format(tag_name))
        exit(1)
    else:
        logging.info(
            "Searching for RPM/DEB packages in GitHub release: {}".format(
                release['url']))
    for asset in release['assets']:
        if re.match(r'.*\.rpm$', asset['name']) \
                or re.match(r'.*\.deb$', asset['name']):
            filename = asset['name']
            asset_id = asset['id']
            asset_url = asset['url']
            if args.debug:
                logging.debug("GitHub asset_url: {}".format(asset_url + '/' +
                                                            filename))

            # Check if the file exists on disk first, and rename it if so
            # to prevent a situation where the expect script fails because
            # the rpm has already been signed
            rename_file_if_exists(filename, logging)

            # Instantiate new requests session, versus reusing the repo session above.
            # Headers was likely being reused in that session, and not allowing us
            # to set the Accept header to the below.
            perform_github_download(asset_url, args, logging, filename,
                                    file_list)

    if len(file_list) < 2:
        logging.error(
            "Cannot get both RPM and DEB files from Github! "
            "Removing partially downloaded files from directory: {}".format(
                dist_dir))
        remove_github_downloaded_files(file_list, logging)
        exit(1)
    return file_list
def main():
  github = GitHub(auth_token())
  releases = github.repos(BROWSER_LAPTOP_REPO).releases.get()
  version = json.load(open('package.json'))['version']
  tag = ('v' + version + release_channel())
  tag_exists = False
  for release in releases:
    if not release['draft'] and release['tag_name'] == tag:
      tag_exists = True
      break
  release = create_or_get_release_draft(github, releases, tag,
                                        tag_exists)
  # match version to GitHub milestone
  commit_tag = None
  parts = version.split('.', 3)
  if (len(parts) == 3):
    parts[2] = 'x'
    commit_tag = '.'.join(parts)

  # Press the publish button.
  if not tag_exists and commit_tag:
    publish_release(github, release['id'], tag, commit_tag)
예제 #17
0
def main():
    args = parse_args()

    if not dist_newer_than_head():
        create_dist = os.path.join(SOURCE_ROOT, 'script', 'create-dist.py')
        execute([sys.executable, create_dist])

    build_version = get_atom_shell_build_version()
    if not ATOM_SHELL_VERSION.startswith(build_version):
        error = 'Tag name ({0}) should match build version ({1})\n'.format(
            ATOM_SHELL_VERSION, build_version)
        sys.stderr.write(error)
        sys.stderr.flush()
        return 1

    # Upload atom-shell with GitHub Releases API.
    github = GitHub(auth_token())
    release_id = create_or_get_release_draft(github, args.version)
    upload_atom_shell(github, release_id, os.path.join(DIST_DIR, DIST_NAME))
    upload_atom_shell(github, release_id, os.path.join(DIST_DIR, SYMBOLS_NAME))

    # Upload chromedriver for minor version update.
    if parse_version(args.version)[2] == '0':
        upload_atom_shell(github, release_id,
                          os.path.join(DIST_DIR, CHROMEDRIVER_NAME))

    if args.publish_release:
        # Upload node's headers to S3.
        bucket, access_key, secret_key = s3_config()
        upload_node(bucket, access_key, secret_key, ATOM_SHELL_VERSION)

        # Upload the SHASUMS.txt.
        execute([
            sys.executable,
            os.path.join(SOURCE_ROOT, 'script', 'upload-checksums.py'), '-v',
            ATOM_SHELL_VERSION
        ])

        # Upload PDBs to Windows symbol server.
        if TARGET_PLATFORM == 'win32':
            execute([
                sys.executable,
                os.path.join(SOURCE_ROOT, 'script', 'upload-windows-pdb.py')
            ])

        # Press the publish button.
        publish_release(github, release_id)
예제 #18
0
def main():
    global tag_names

    supported_platforms = ['Darwin']

    if platform.system() not in supported_platforms:
        print(
            'Error: Platform \'{}\' not supported; acceptable platform(s): {}'.
            format(platform.system(), ", ".join(supported_platforms)))
        exit(1)

    args = parse_args()
    if args.real_profile and args.use_profile:
        print(
            '[ERROR] you can\'t use both `--fresh-profile` AND `--use-profile` at the same time.'
        )
        return 1

    github_token = get_github_token()
    repo = GitHub(github_token).repos(BRAVE_REPO)

    get_releases(repo)
    tag_names.sort(key=lambda s: map(int, s.split('.')))

    filter_releases(args)
    first_broken_version, attempts = find_first_broken_version(args)
    print('DONE: issue first appeared in "' + str(first_broken_version) +
          '" (found in ' + str(attempts) + ' attempts)')

    try:
        broken_index = tag_names.index(first_broken_version)
        if broken_index > 0:
            previous_release = tag_names[broken_index - 1]
            versions = 'v' + previous_release + '..v' + first_broken_version
            if args.verbose:
                print(
                    '[INFO] finding commits using "git log --pretty=oneline ' +
                    versions + '"')
            commits = execute(['git', 'log', '--pretty=oneline',
                               versions]).strip()
            commit_lines = commits.split('\n')
            print('Commits specific to tag "v' + first_broken_version + '" (' +
                  str(len(commit_lines)) + ' commit(s)):')
            print(commits)
    except Exception as e:
        print('[ERROR] ' + str(e))
예제 #19
0
def is_sha(ref):
    global config
    repo = GitHub(config.github_token).repos(BRAVE_CORE_REPO)
    try:
        repo.git.commits(str(ref)).get()
    except Exception as e:
        response = str(e)
        try:
            # Unsure of original intention, but github.py (on purpose) throws
            # an exception if the response body contains `message`.
            # This catch has the response (in JSON) in exception
            json_response = json.loads(response)
            if json_response['sha'] == ref:
                return True
        except Exception as e2:
            return False
        return False
예제 #20
0
def main(args):
    print('[INFO] Running upload...')
    repo = GitHub(get_env('GITHUB_TOKEN')).repos(BROWSER_LAPTOP_REPO)

    tag = get_tag_without_channel()
    release = get_draft(repo, tag)

    if not release:
        print(
            "[INFO] No existing release found, creating new release for this upload"
        )
        release = create_release_draft(repo, tag)

    print('[INFO] Uploading release {}'.format(release['tag_name']))
    for f in get_files_to_upload():
        upload_browser_laptop(repo, release, f, force=args.force)
    print('[INFO] Finished upload')
예제 #21
0
def main():

    args = parse_args()

    if args.debug:
        logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
        logging.debug('prerelease: {}'.format(args.prerelease))

    if not os.environ.get('npm_config_onevn_version'):
        message = ('Error: Please set the $npm_config_onevn_version'
                   'environment variable')
        exit(message)

    ONEVN_VERSION = os.environ.get('npm_config_onevn_version')

    repo = GitHub(get_env_var('GITHUB_TOKEN')).repos(ONEVN_REPO)

    release = get_draft(repo, ONEVN_VERSION)

    tag_name = release['tag_name']

    logging.info("Releasing {}".format(tag_name))
    publish_release(repo, release['id'], tag_name, args.prerelease, logging)
예제 #22
0
파일: uplift.py 프로젝트: Snuupy/brave-core
def main():
    args = parse_args()
    if args.verbose:
        print('[INFO] args: ' + str(args))

    global config
    result = config.initialize(args)
    if result != 0:
        return result

    result = fetch_origin_check_staged(BRAVE_CORE_ROOT)
    if result != 0:
        return result

    # get all channel branches (starting at master)
    brave_browser_version = get_remote_version('master')
    remote_branches = get_remote_channel_branches(brave_browser_version)
    top_level_base = 'master'

    # if starting point is NOT nightly, remove options which aren't desired
    # also, find the branch which should be used for diffs (for cherry-picking)
    if not is_nightly(args.start_from):
        top_level_base = remote_branches[args.start_from]
        try:
            start_index = config.channel_names.index(args.start_from)
            config.channels_to_process = config.channel_names[start_index:]
        except Exception as e:
            print('[ERROR] specified `start-from` value "' + args.start_from + '" not found in channel list')
            return 1

    # optionally (instead of having a local branch), allow uplifting a specific PR
    # this pulls down the pr locally (in a special branch)
    if args.uplift_using_pr:
        try:
            pr_number = int(args.uplift_using_pr)
            repo = GitHub(config.github_token).repos(BRAVE_CORE_REPO)
            # get enough details from PR to check out locally
            response = repo.pulls(pr_number).get()
            head = response['head']
            local_branch = 'pr' + str(pr_number) + '_' + head['ref']
            head_sha = head['sha']
            top_level_base = response['base']['ref']
            top_level_sha = response['base']['sha']
            merged_at = str(response['merged_at']).strip()
            config.title = str(response['title']).strip()

        except Exception as e:
            print('[ERROR] Error parsing or error returned from API when looking up pull request "' +
                  str(args.uplift_using_pr) + '":\n' + str(e))
            return 1

        # set starting point AHEAD of the PR provided
        config.master_pr_number = pr_number
        if top_level_base == 'master':
            config.channels_to_process = config.channel_names[1:]
        else:
            branch_index = remote_branches.index(top_level_base)
            config.channels_to_process = config.channel_names[branch_index:]

        # if PR was already merged, use the SHA it was PRed against
        if merged_at != 'None' and len(merged_at) > 0:
            print('pr was already merged at ' + merged_at + '; using "' + top_level_sha +
                  '" instead of "' + top_level_base + '"')
            top_level_base = top_level_sha
        else:
            # don't allow uplift of PRs which are not merged
            print('[ERROR] Pull request ' + str(pr_number) + ' has not been merged yet. ' +
                  'Only merged requests can be uplifted.')
            return 1

        # create local branch which matches the contents of the PR
        with scoped_cwd(BRAVE_CORE_ROOT):
            # check if branch exists already
            try:
                branch_sha = execute(['git', 'rev-parse', '-q', '--verify', local_branch])
            except Exception as e:
                branch_sha = ''
            if len(branch_sha) > 0:
                # branch exists; reset it
                print('branch "' + local_branch + '" exists; resetting to origin/' + head['ref'] +
                      ' (' + head_sha + ')')
                execute(['git', 'checkout', local_branch])
                execute(['git', 'reset', '--hard', head_sha])
            else:
                # create the branch
                print('creating branch "' + local_branch + '" using origin/' + head['ref'] + ' (' + head_sha + ')')
                execute(['git', 'checkout', '-b', local_branch, head_sha])

    # If title isn't set already, generate one from first commit
    local_branch = get_local_branch_name(BRAVE_CORE_ROOT)
    if not config.title and not args.uplift_using_pr:
        config.title = get_title_from_first_commit(BRAVE_CORE_ROOT, top_level_base)

    # Create a branch for each channel
    print('\nCreating branches...')
    fancy_print('NOTE: Commits are being detected by diffing "' + local_branch + '" against "' + top_level_base + '"')
    local_branches = {}
    branch = ''
    try:
        for channel in config.channels_to_process:
            branch = create_branch(channel, top_level_base, remote_branches[channel], local_branch, args)
            local_branches[channel] = branch
            if channel == args.uplift_to:
                break
    except Exception as e:
        print('[ERROR] cherry-pick failed for branch "' + branch + '". Please resolve manually:\n' + str(e))
        return 1

    print('\nPushing local branches to remote...')
    push_branches_to_remote(BRAVE_CORE_ROOT, config.branches_to_push,
                            dryrun=config.is_dryrun, token=config.github_token)

    try:
        print('\nCreating the pull requests...')
        for channel in config.channels_to_process:
            submit_pr(
                channel,
                top_level_base,
                remote_branches[channel],
                local_branches[channel])
            if channel == args.uplift_to:
                break
        print('\nDone!')
    except Exception as e:
        print('\n[ERROR] Unhandled error while creating pull request; ' + str(e))
        return 1

    return 0
예제 #23
0
파일: upload.py 프로젝트: xiwc/electron
def main():
    args = parse_args()

    if not args.publish_release:
        if not dist_newer_than_head():
            create_dist = os.path.join(SOURCE_ROOT, 'script', 'create-dist.py')
            execute([sys.executable, create_dist])

        build_version = get_atom_shell_build_version()
        if not ATOM_SHELL_VERSION.startswith(build_version):
            error = 'Tag name ({0}) should match build version ({1})\n'.format(
                ATOM_SHELL_VERSION, build_version)
            sys.stderr.write(error)
            sys.stderr.flush()
            return 1

    github = GitHub(auth_token())
    releases = github.repos(ATOM_SHELL_REPO).releases.get()
    tag_exists = False
    for release in releases:
        if not release['draft'] and release['tag_name'] == args.version:
            tag_exists = True
            break

    release = create_or_get_release_draft(github, releases, args.version,
                                          tag_exists)

    if args.publish_release:
        # Upload the SHASUMS.txt.
        execute([
            sys.executable,
            os.path.join(SOURCE_ROOT, 'script', 'upload-checksums.py'), '-v',
            ATOM_SHELL_VERSION
        ])

        # Upload the index.json.
        execute([
            sys.executable,
            os.path.join(SOURCE_ROOT, 'script', 'upload-index-json.py')
        ])

        # Press the publish button.
        publish_release(github, release['id'])

        # Do not upload other files when passed "-p".
        return

    # Upload atom-shell with GitHub Releases API.
    upload_atom_shell(github, release, os.path.join(DIST_DIR, DIST_NAME))
    upload_atom_shell(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME))

    # Upload chromedriver and mksnapshot for minor version update.
    if parse_version(args.version)[2] == '0':
        chromedriver = 'chromedriver-{0}-{1}-{2}.zip'.format(
            get_chromedriver_version(), get_platform_key(), get_target_arch())
        upload_atom_shell(github, release,
                          os.path.join(DIST_DIR, chromedriver))
        upload_atom_shell(github, release,
                          os.path.join(DIST_DIR, MKSNAPSHOT_NAME))

    if PLATFORM == 'win32' and not tag_exists:
        # Upload node headers.
        execute([
            sys.executable,
            os.path.join(SOURCE_ROOT, 'script', 'upload-node-headers.py'),
            '-v', args.version
        ])
예제 #24
0
def main():
    args = parse_args()
    print('[INFO] Running upload...')

    # Enable urllib3 debugging output
    if os.environ.get('DEBUG_HTTP_HEADERS') == 'true':
        logging.basicConfig(level=logging.DEBUG)
        logging.getLogger("urllib3").setLevel(logging.DEBUG)
        logging.debug(
            "DEBUG_HTTP_HEADERS env var is enabled, logging HTTP headers")
        debug_requests_on()

    # BRAVE_REPO is defined in lib/helpers.py for now
    repo = GitHub(get_env_var('GITHUB_TOKEN')).repos(BRAVE_REPO)

    tag = get_brave_version()
    release = get_release(repo, tag, allow_published_release_updates=False)

    if not release:
        print("[INFO] No existing release found, creating new "
              "release for this upload")
        release = create_release_draft(repo, tag)

    print('[INFO] Uploading release {}'.format(release['tag_name']))
    # Upload Brave with GitHub Releases API.
    upload_brave(repo,
                 release,
                 os.path.join(dist_dir(), DIST_NAME),
                 force=args.force)
    upload_brave(repo,
                 release,
                 os.path.join(dist_dir(), SYMBOLS_NAME),
                 force=args.force)
    # if PLATFORM == 'darwin':
    #     upload_brave(repo, release, os.path.join(dist_dir(), DSYM_NAME))
    # elif PLATFORM == 'win32':
    #     upload_brave(repo, release, os.path.join(dist_dir(), PDB_NAME))

    pkgs = get_brave_packages(output_dir(), release_channel(),
                              get_raw_version())

    if PLATFORM == 'darwin':
        for pkg in pkgs:
            upload_brave(repo,
                         release,
                         os.path.join(output_dir(), pkg),
                         force=args.force)
    elif PLATFORM == 'win32':
        if get_target_arch() == 'x64':
            upload_brave(repo,
                         release,
                         os.path.join(output_dir(), 'brave_installer.exe'),
                         'brave_installer-x64.exe',
                         force=args.force)
            for pkg in pkgs:
                upload_brave(repo,
                             release,
                             os.path.join(output_dir(), pkg),
                             force=args.force)
        else:
            upload_brave(repo,
                         release,
                         os.path.join(output_dir(), 'brave_installer.exe'),
                         'brave_installer-ia32.exe',
                         force=args.force)
            for pkg in pkgs:
                upload_brave(repo,
                             release,
                             os.path.join(output_dir(), pkg),
                             force=args.force)
    else:
        if get_target_arch() == 'x64':
            for pkg in pkgs:
                upload_brave(repo,
                             release,
                             os.path.join(output_dir(), pkg),
                             force=args.force)
        else:
            upload_brave(repo,
                         release,
                         os.path.join(output_dir(), 'brave-i386.rpm'),
                         force=args.force)
            upload_brave(repo,
                         release,
                         os.path.join(output_dir(), 'brave-i386.deb'),
                         force=args.force)

    # mksnapshot = get_zip_name('mksnapshot', get_brave_version())
    # upload_brave(repo, release, os.path.join(dist_dir(), mksnapshot))

    # if PLATFORM == 'win32' and not tag_exists:
    #     # Upload PDBs to Windows symbol server.
    #     run_python_script('upload-windows-pdb.py')

    if os.environ.get('DEBUG_HTTP_HEADERS') == 'true':
        debug_requests_off()
    print('[INFO] Finished upload')
예제 #25
0
def main():
    args = parse_args()

    if not args.publish_release:
        build_version = get_brave_version()
        if not get_brave_version().startswith(build_version):
            error = 'Tag name ({0}) should match build version ({1})\n'.format(
                get_brave_version(), build_version)
            sys.stderr.write(error)
            sys.stderr.flush()
            return 1

    github = GitHub(auth_token())
    releases = github.repos(BRAVE_REPO).releases.get()
    tag_exists = False
    for release in releases:
        if not release['draft'] and release['tag_name'] == args.version:
            tag_exists = True
            break

    release = create_or_get_release_draft(github, releases, args.version,
                                          tag_exists)

    if args.publish_release:
        # Create and upload the Brave SHASUMS*.txt
        release_brave_checksums(github, release)

        # Press the publish button.
        # publish_release(github, release['id'])

        # Do not upload other files when passed "-p".
        return

    # Upload Brave with GitHub Releases API.
    upload_brave(github, release, os.path.join(dist_dir(), DIST_NAME))
    upload_brave(github, release, os.path.join(dist_dir(), SYMBOLS_NAME))
    # if PLATFORM == 'darwin':
    #   upload_brave(github, release, os.path.join(dist_dir(), DSYM_NAME))
    # elif PLATFORM == 'win32':
    #   upload_brave(github, release, os.path.join(dist_dir(), PDB_NAME))

    # Upload chromedriver and mksnapshot.
    chromedriver = get_zip_name('chromedriver', get_chromedriver_version())
    upload_brave(github, release, os.path.join(dist_dir(), chromedriver))

    if PLATFORM == 'darwin':
        upload_brave(github, release, os.path.join(output_dir(), 'Brave.dmg'))
    elif PLATFORM == 'win32':
        if get_target_arch() == 'x64':
            upload_brave(github, release,
                         os.path.join(output_dir(), 'brave_installer.exe'),
                         'brave_installer-x64.exe')
        else:
            upload_brave(github, release,
                         os.path.join(output_dir(), 'brave_installer.exe'),
                         'brave_installer-ia32.exe')
    # TODO: Enable after linux packaging lands
    #else:
    #if get_target_arch() == 'x64':
    #upload_brave(github, release, os.path.join(output_dir(), 'brave-x86_64.rpm'))
    #upload_brave(github, release, os.path.join(output_dir(), 'brave-amd64.deb'))
    #else:
    #upload_brave(github, release, os.path.join(output_dir(), 'brave-i386.rpm'))
    #upload_brave(github, release, os.path.join(output_dir(), 'brave-i386.deb'))

    # mksnapshot = get_zip_name('mksnapshot', get_brave_version())
    # upload_brave(github, release, os.path.join(dist_dir(), mksnapshot))

    # if PLATFORM == 'win32' and not tag_exists:
    #   # Upload PDBs to Windows symbol server.
    #   run_python_script('upload-windows-pdb.py')

    versions = parse_version(args.version)
    version = '.'.join(versions[:3])
예제 #26
0
def download_from_github(args, logging):
    file_list = []

    # BRAVE_REPO defined in helpers.py
    repo = GitHub(get_env_var('GITHUB_TOKEN')).repos(BRAVE_REPO)

    if args.tag:
        tag_name = args.tag
    else:
        tag_name = get_brave_version()

    release = None
    releases = get_releases_by_tag(repo, tag_name, include_drafts=True)
    if releases:
        if len(releases) > 1:
            exit("Error: More than 1 release exists with the tag: \'{}\'".format(tag_name))
        release = releases[0]

    for asset in release['assets']:
        if re.match(r'.*\.dmg$', asset['name']) \
                or re.match(r'brave_installer.*\.exe$', asset['name']):
            filename = asset['name']
            asset_url = asset['url']
            if args.debug:
                logging.debug("GitHub asset_url: {}".format(
                    asset_url + '/' + filename))

            # Instantiate new requests session, versus reusing the repo session above.
            # Headers was likely being reused in that session, and not allowing us
            # to set the Accept header to the below.
            headers = {'Accept': 'application/octet-stream'}

            asset_auth_url = asset_url + '?access_token=' + \
                os.environ.get('BRAVE_GITHUB_TOKEN')

            if args.debug:
                # disable urllib3 logging for this session to avoid showing
                # access_token in logs
                logging.getLogger("urllib3").setLevel(logging.WARNING)

            r = requests.get(asset_auth_url, headers=headers, stream=True)

            if args.debug:
                logging.getLogger("urllib3").setLevel(logging.DEBUG)

            with open(filename, 'wb') as f:
                for chunk in r.iter_content(chunk_size=1024):
                    if chunk:
                        f.write(chunk)

            logging.debug(
                "Requests Response status_code: {}".format(r.status_code))
            if r.status_code == 200:
                file_list.append('./' + filename)
            else:
                logging.debug(
                    "Requests Response status_code != 200: {}".format(r.status_code))

    if len(file_list) < 3:
        logging.error(
            "Cannot get all 3 install files from Github! (\'*.dmg\', \'brave_installer-x64.exe\',"
            " \'brave-installer-ia32.exe\')")
        remove_github_downloaded_files(file_list, logging)
        exit(1)

    return file_list
예제 #27
0
def main():
    args = parse_args()
    print('[INFO] Running upload...')

    # Repo is defined in lib/helpers.py for now
    repo = GitHub(get_env_var('GITHUB_TOKEN')).repos(BRAVE_REPO)

    tag = get_brave_version()
    release = get_draft(repo, tag)

    if not release:
        print(
            "[INFO] No existing release found, creating new release for this upload"
        )
        release = create_release_draft(repo, tag)

    print('[INFO] Uploading release {}'.format(release['tag_name']))
    # Upload Brave with GitHub Releases API.
    upload_brave(repo,
                 release,
                 os.path.join(dist_dir(), DIST_NAME),
                 force=args.force)
    upload_brave(repo,
                 release,
                 os.path.join(dist_dir(), SYMBOLS_NAME),
                 force=args.force)
    # if PLATFORM == 'darwin':
    #   upload_brave(repo, release, os.path.join(dist_dir(), DSYM_NAME))
    # elif PLATFORM == 'win32':
    #   upload_brave(repo, release, os.path.join(dist_dir(), PDB_NAME))

    # Upload chromedriver and mksnapshot.
    chromedriver = get_zip_name('chromedriver', get_chromedriver_version())
    upload_brave(repo,
                 release,
                 os.path.join(dist_dir(), chromedriver),
                 force=args.force)

    pkgs = yield_brave_packages(output_dir(), release_channel(),
                                get_raw_version())

    if PLATFORM == 'darwin':
        for pkg in pkgs:
            upload_brave(repo,
                         release,
                         os.path.join(output_dir(), pkg),
                         force=args.force)
    elif PLATFORM == 'win32':
        if get_target_arch() == 'x64':
            upload_brave(repo,
                         release,
                         os.path.join(output_dir(), 'brave_installer.exe'),
                         'brave_installer-x64.exe',
                         force=args.force)
        else:
            upload_brave(repo,
                         release,
                         os.path.join(output_dir(), 'brave_installer.exe'),
                         'brave_installer-ia32.exe',
                         force=args.force)
    else:
        if get_target_arch() == 'x64':
            for pkg in pkgs:
                upload_brave(repo,
                             release,
                             os.path.join(output_dir(), pkg),
                             force=args.force)
        else:
            upload_brave(repo,
                         release,
                         os.path.join(output_dir(), 'brave-i386.rpm'),
                         force=args.force)
            upload_brave(repo,
                         release,
                         os.path.join(output_dir(), 'brave-i386.deb'),
                         force=args.force)

    # mksnapshot = get_zip_name('mksnapshot', get_brave_version())
    # upload_brave(repo, release, os.path.join(dist_dir(), mksnapshot))

    # if PLATFORM == 'win32' and not tag_exists:
    #   # Upload PDBs to Windows symbol server.
    #   run_python_script('upload-windows-pdb.py')

    versions = parse_version(args.version)
    version = '.'.join(versions[:3])
    print('[INFO] Finished upload')
예제 #28
0
def main():
  args = parse_args()

  if not dist_newer_than_head():
    run_python_script('create-dist.py')

  build_version = get_electron_build_version()
  if not ELECTRON_VERSION.startswith(build_version):
    error = 'Tag name ({0}) should match build version ({1})\n'.format(
        ELECTRON_VERSION, build_version)
    sys.stderr.write(error)
    sys.stderr.flush()
    return 1

  github = GitHub(auth_token())
  releases = github.repos(ELECTRON_REPO).releases.get()
  tag_exists = False
  for r in releases:
    if not r['draft'] and r['tag_name'] == args.version:
      release = r
      tag_exists = True
      break

  if not args.upload_to_s3:
    assert tag_exists == args.overwrite, \
          'You have to pass --overwrite to overwrite a published release'
    if not args.overwrite:
      release = create_or_get_release_draft(github, releases, args.version,
                                            tag_exists)

  # Upload Electron with GitHub Releases API.
  upload_electron(github, release, os.path.join(DIST_DIR, DIST_NAME),
                  args.upload_to_s3)
  if get_target_arch() != 'mips64el':
    upload_electron(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME),
                    args.upload_to_s3)
  if PLATFORM == 'darwin':
    upload_electron(github, release, os.path.join(DIST_DIR,
                    'electron-api.json'), args.upload_to_s3)
    upload_electron(github, release, os.path.join(DIST_DIR, 'electron.d.ts'),
                    args.upload_to_s3)
    upload_electron(github, release, os.path.join(DIST_DIR, DSYM_NAME),
                    args.upload_to_s3)
  elif PLATFORM == 'win32':
    upload_electron(github, release, os.path.join(DIST_DIR, PDB_NAME),
                    args.upload_to_s3)

  # Upload free version of ffmpeg.
  ffmpeg = get_zip_name('ffmpeg', ELECTRON_VERSION)
  upload_electron(github, release, os.path.join(DIST_DIR, ffmpeg),
                  args.upload_to_s3)

  chromedriver = get_zip_name('chromedriver', ELECTRON_VERSION)
  upload_electron(github, release, os.path.join(DIST_DIR, chromedriver),
                  args.upload_to_s3)
  mksnapshot = get_zip_name('mksnapshot', ELECTRON_VERSION)
  upload_electron(github, release, os.path.join(DIST_DIR, mksnapshot),
                args.upload_to_s3)

  if get_target_arch().startswith('arm'):
    # Upload the x64 binary for arm/arm64 mksnapshot
    mksnapshot = get_zip_name('mksnapshot', ELECTRON_VERSION, 'x64')
    upload_electron(github, release, os.path.join(DIST_DIR, mksnapshot),
                    args.upload_to_s3)

  if PLATFORM == 'win32' and not tag_exists and not args.upload_to_s3:
    # Upload PDBs to Windows symbol server.
    run_python_script('upload-windows-pdb.py')

    # Upload node headers.
    run_python_script('create-node-headers.py', '-v', args.version)
    run_python_script('upload-node-headers.py', '-v', args.version)
예제 #29
0
def main():
    args = parse_args()
    if args.upload_to_s3:
        utcnow = datetime.datetime.utcnow()
        args.upload_timestamp = utcnow.strftime('%Y-%m-%d_%H:%M:%S')

    if not dist_newer_than_head():
        run_python_script('create-dist.py')

    build_version = get_electron_build_version()
    if not ELECTRON_VERSION.startswith(build_version):
        error = 'Tag name ({0}) should match build version ({1})\n'.format(
            ELECTRON_VERSION, build_version)
        sys.stderr.write(error)
        sys.stderr.flush()
        return 1

    github = GitHub(auth_token())
    releases = github.repos(ELECTRON_REPO).releases.get()
    tag_exists = False
    release = None
    for r in releases:
        if not r['draft'] and r['tag_name'] == args.version:
            release = r
            tag_exists = True
            break

    if not args.upload_to_s3:
        assert tag_exists == args.overwrite, \
              'You have to pass --overwrite to overwrite a published release'
        if not args.overwrite:
            release = create_or_get_release_draft(github, releases,
                                                  args.version, tag_exists)
    elif release is None:
        release = dict(tag_name=args.version)

    # Upload Electron with GitHub Releases API.
    upload_electron(github, release, os.path.join(DIST_DIR, DIST_NAME), args)
    if get_target_arch() != 'mips64el':
        upload_electron(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME),
                        args)
    if PLATFORM == 'darwin':
        upload_electron(github, release,
                        os.path.join(DIST_DIR, 'electron-api.json'), args)
        upload_electron(github, release, os.path.join(DIST_DIR,
                                                      'electron.d.ts'), args)
        upload_electron(github, release, os.path.join(DIST_DIR, DSYM_NAME),
                        args)
    elif PLATFORM == 'win32':
        upload_electron(github, release, os.path.join(DIST_DIR, PDB_NAME),
                        args)

    # Upload free version of ffmpeg.
    ffmpeg = get_zip_name('ffmpeg', ELECTRON_VERSION)
    upload_electron(github, release, os.path.join(DIST_DIR, ffmpeg), args)

    chromedriver = get_zip_name('chromedriver', ELECTRON_VERSION)
    upload_electron(github, release, os.path.join(DIST_DIR, chromedriver),
                    args)
    mksnapshot = get_zip_name('mksnapshot', ELECTRON_VERSION)
    upload_electron(github, release, os.path.join(DIST_DIR, mksnapshot), args)

    if get_target_arch().startswith('arm'):
        # Upload the x64 binary for arm/arm64 mksnapshot
        mksnapshot = get_zip_name('mksnapshot', ELECTRON_VERSION, 'x64')
        upload_electron(github, release, os.path.join(DIST_DIR, mksnapshot),
                        args)

    if not tag_exists and not args.upload_to_s3:
        # Upload symbols to symbol server.
        run_python_script('upload-symbols.py')
        if PLATFORM == 'win32':
            # Upload node headers.
            run_python_script('create-node-headers.py', '-v', args.version)
            run_python_script('upload-node-headers.py', '-v', args.version)
예제 #30
0
def main():
    args = parse_args()
    if args.verbose:
        print('[INFO] args: ' + str(args))

    global config
    result = config.initialize(args)
    if result != 0:
        return result

    result = fetch_origin_check_staged(BRAVE_CORE_ROOT)
    if result != 0:
        return result

    # get all channel branches (starting at master)
    brave_browser_version = get_remote_version('master')
    remote_branches = get_remote_channel_branches(brave_browser_version)
    top_level_base = 'master'

    # if starting point is NOT nightly, remove options which aren't desired
    # also, find the branch which should be used for diffs (for cherry-picking)
    if not is_nightly(args.start_from):
        top_level_base = remote_branches[args.start_from]
        try:
            start_index = config.channel_names.index(args.start_from)
            config.channels_to_process = config.channel_names[start_index:]
        except Exception as e:
            print('[ERROR] specified `start-from` value "' + args.start_from +
                  '" not found in channel list')
            return 1

    # optionally (instead of having a local branch), allow uplifting a specific PR
    # this pulls down the pr locally (in a special branch)
    if args.uplift_using_pr:
        try:
            pr_number = int(args.uplift_using_pr)
            repo = GitHub(config.github_token).repos(BRAVE_CORE_REPO)
            # get enough details from PR to check out locally
            response = repo.pulls(pr_number).get()
            head = response['head']
            local_branch = 'pr' + str(pr_number) + '_' + head['ref']
            head_sha = head['sha']
            top_level_base = response['base']['ref']
            top_level_sha = response['base']['sha']
            merged_at = str(response['merged_at']).strip()
            config.title = str(response['title']).strip()

        except Exception as e:
            print(
                '[ERROR] Error parsing or error returned from API when looking up pull request "'
                + str(args.uplift_using_pr) + '":\n' + str(e))
            return 1

        # set starting point AHEAD of the PR provided
        config.master_pr_number = pr_number
        if top_level_base == 'master':
            config.channels_to_process = config.channel_names[1:]
        else:
            branch_index = remote_branches.index(top_level_base)
            config.channels_to_process = config.channel_names[branch_index:]

        # if PR was already merged, use the SHA it was PRed against
        if merged_at != 'None' and len(merged_at) > 0:
            print('pr was already merged at ' + merged_at + '; using "' +
                  top_level_sha + '" instead of "' + top_level_base + '"')
            top_level_base = top_level_sha
        else:
            # don't allow uplift of PRs which are not merged
            print('[ERROR] Pull request ' + str(pr_number) +
                  ' has not been merged yet. ' +
                  'Only merged requests can be uplifted.')
            return 1

        # create local branch which matches the contents of the PR
        with scoped_cwd(BRAVE_CORE_ROOT):
            # check if branch exists already
            try:
                branch_sha = execute(
                    ['git', 'rev-parse', '-q', '--verify', local_branch])
            except Exception as e:
                branch_sha = ''
            if len(branch_sha) > 0:
                # branch exists; reset it
                print('branch "' + local_branch +
                      '" exists; resetting to origin/' + head['ref'] + ' (' +
                      head_sha + ')')
                execute(['git', 'checkout', local_branch])
                execute(['git', 'reset', '--hard', head_sha])
            else:
                # create the branch
                print('creating branch "' + local_branch + '" using origin/' +
                      head['ref'] + ' (' + head_sha + ')')
                execute(['git', 'checkout', '-b', local_branch, head_sha])

    # If title isn't set already, generate one from first commit
    local_branch = get_local_branch_name(BRAVE_CORE_ROOT)
    if not config.title and not args.uplift_using_pr:
        config.title = get_title_from_first_commit(BRAVE_CORE_ROOT,
                                                   top_level_base)

    # Create a branch for each channel
    print('\nCreating branches...')
    fancy_print('NOTE: Commits are being detected by diffing "' +
                local_branch + '" against "' + top_level_base + '"')
    local_branches = {}
    branch = ''
    try:
        for channel in config.channels_to_process:
            branch = create_branch(channel, top_level_base,
                                   remote_branches[channel], local_branch)
            local_branches[channel] = branch
            if channel == args.uplift_to:
                break
    except Exception as e:
        print('[ERROR] cherry-pick failed for branch "' + branch +
              '". Please resolve manually:\n' + str(e))
        return 1

    print('\nPushing local branches to remote...')
    push_branches_to_remote(BRAVE_CORE_ROOT,
                            config.branches_to_push,
                            dryrun=config.is_dryrun,
                            token=config.github_token)

    try:
        print('\nCreating the pull requests...')
        for channel in config.channels_to_process:
            submit_pr(channel, top_level_base, remote_branches[channel],
                      local_branches[channel])
            if channel == args.uplift_to:
                break
        print('\nDone!')
    except Exception as e:
        print('\n[ERROR] Unhandled error while creating pull request; ' +
              str(e))
        return 1

    return 0
예제 #31
0
def download_from_github(args, logging):
    file_list = []

    # BRAVE_REPO defined in helpers.py
    repo = GitHub(get_env_var('GITHUB_TOKEN')).repos(BRAVE_REPO)

    if args.tag:
        tag_name = args.tag
    else:
        tag_name = get_brave_version()

    release = None
    releases = get_releases_by_tag(repo, tag_name, include_drafts=True)
    if releases:
        if len(releases) > 1:
            exit("Error: More than 1 release exists with the tag: \'{}\'".
                 format(tag_name))
        release = releases[0]
    else:
        exit("Error: Did not get the release \'{}\' from Github.".format(
            tag_name))

    found_assets_in_github_release = {}

    for asset in release['assets']:
        if re.match(r'.*\.dmg$', asset['name']):
            if args.uploaded:
                if not args.platform:
                    args.platform = []
                args.platform.append('darwin')
            found_assets_in_github_release['darwin'] = {}
            found_assets_in_github_release['darwin']['name'] = asset['name']
            found_assets_in_github_release['darwin']['url'] = asset['url']
        elif re.match(r'brave_installer-ia32\.exe$', asset['name']):
            if args.uploaded:
                if not args.platform:
                    args.platform = []
                args.platform.append('win32')
            found_assets_in_github_release['win32'] = {}
            found_assets_in_github_release['win32']['name'] = asset['name']
            found_assets_in_github_release['win32']['url'] = asset['url']
        elif re.match(r'brave_installer-x64\.exe$', asset['name']):
            if args.uploaded:
                if not args.platform:
                    args.platform = []
                args.platform.append('win64')
            found_assets_in_github_release['win64'] = {}
            found_assets_in_github_release['win64']['name'] = asset['name']
            found_assets_in_github_release['win64']['url'] = asset['url']

    logging.debug("Found assets in github release: {}".format(
        found_assets_in_github_release))

    for requested_platform in args.platform:
        logging.debug(
            "Verifying platform \'{}\' exists in GitHub release".format(
                requested_platform))
        if requested_platform not in found_assets_in_github_release.keys():
            logging.error(
                "Platform \'{}\' does not exist in GitHub release".format(
                    requested_platform))
            exit(1)

    for platform in args.platform:
        if args.debug:
            logging.debug("GitHub asset_url: {}".format(
                found_assets_in_github_release[platform]['url'] + '/' +
                found_assets_in_github_release[platform]['name']))

        # Instantiate new requests session, versus reusing the repo session above.
        # Headers was likely being reused in that session, and not allowing us
        # to set the Accept header to the below.
        headers = {
            'Accept': 'application/octet-stream',
            'Authorization': 'token ' + get_env_var('GITHUB_TOKEN')
        }

        asset_url = found_assets_in_github_release[platform]['url']

        if args.debug:
            # disable urllib3 logging for this session to avoid showing
            # access_token in logs
            logging.getLogger("urllib3").setLevel(logging.WARNING)

        r = requests.get(asset_url, headers=headers, stream=True)

        if args.debug:
            logging.getLogger("urllib3").setLevel(logging.DEBUG)

        logging.debug("Writing GitHub download to file: {}".format(
            found_assets_in_github_release[platform]['name']))

        with open(found_assets_in_github_release[platform]['name'], 'wb') as f:
            for chunk in r.iter_content(chunk_size=1024):
                if chunk:
                    f.write(chunk)

        logging.debug("Requests Response status_code: {}".format(
            r.status_code))
        if r.status_code == 200:
            file_list.append('./' +
                             found_assets_in_github_release[platform]['name'])
        else:
            logging.debug("Requests Response status_code != 200: {}".format(
                r.status_code))

    if len(file_list) < len(args.platform):
        for item in args.platform:
            logging.error("Cannot get requested file from Github! {}".format(
                found_assets_in_github_release[item]['name']))
        remove_github_downloaded_files(file_list, logging)
        exit(1)

    return file_list
예제 #32
0
def main():
    args = parse_args()

    if not args.publish_release:
        if not dist_newer_than_head():
            run_python_script('create-dist.py')

        build_version = get_electron_build_version()
        if not ELECTRON_VERSION.startswith(build_version):
            error = 'Tag name ({0}) should match build version ({1})\n'.format(
                ELECTRON_VERSION, build_version)
            sys.stderr.write(error)
            sys.stderr.flush()
            return 1

    github = GitHub(auth_token())
    releases = github.repos(ELECTRON_REPO).releases.get()
    tag_exists = False
    for release in releases:
        if not release['draft'] and release['tag_name'] == args.version:
            tag_exists = True
            break

    release = create_or_get_release_draft(github, releases, args.version,
                                          tag_exists)

    if args.publish_release:
        # Upload the Node SHASUMS*.txt.
        run_python_script('upload-node-checksums.py', '-v', ELECTRON_VERSION)

        # Upload the index.json.
        run_python_script('upload-index-json.py')

        # Create and upload the Electron SHASUMS*.txt
        release_electron_checksums(github, release)

        # Press the publish button.
        publish_release(github, release['id'])

        # Do not upload other files when passed "-p".
        return

    # Upload Electron with GitHub Releases API.
    upload_electron(github, release, os.path.join(DIST_DIR, DIST_NAME))
    upload_electron(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME))
    if PLATFORM == 'darwin':
        upload_electron(github, release,
                        os.path.join(DIST_DIR, 'electron-api.json'))
        upload_electron(github, release, os.path.join(DIST_DIR,
                                                      'electron.d.ts'))
        upload_electron(github, release, os.path.join(DIST_DIR, DSYM_NAME))
    elif PLATFORM == 'win32':
        upload_electron(github, release, os.path.join(DIST_DIR, PDB_NAME))

    # Upload free version of ffmpeg.
    ffmpeg = get_zip_name('ffmpeg', ELECTRON_VERSION)
    upload_electron(github, release, os.path.join(DIST_DIR, ffmpeg))

    # Upload chromedriver and mksnapshot for minor version update.
    if parse_version(args.version)[2] == '0':
        chromedriver = get_zip_name('chromedriver', ELECTRON_VERSION)
        upload_electron(github, release, os.path.join(DIST_DIR, chromedriver))
        mksnapshot = get_zip_name('mksnapshot', ELECTRON_VERSION)
        upload_electron(github, release, os.path.join(DIST_DIR, mksnapshot))

    if PLATFORM == 'win32' and not tag_exists:
        # Upload PDBs to Windows symbol server.
        run_python_script('upload-windows-pdb.py')

        # Upload node headers.
        run_python_script('create-node-headers.py', '-v', args.version)
        run_python_script('upload-node-headers.py', '-v', args.version)
예제 #33
0
def main():
  args = parse_args()

  if not args.publish_release:
    if not dist_newer_than_head():
      run_python_script('create-dist.py')

    build_version = get_electron_build_version()
    if not ELECTRON_VERSION.startswith(build_version):
      error = 'Tag name ({0}) should match build version ({1})\n'.format(
          ELECTRON_VERSION, build_version)
      sys.stderr.write(error)
      sys.stderr.flush()
      return 1

  github = GitHub(auth_token())
  releases = github.repos(ELECTRON_REPO).releases.get()
  tag_exists = False
  for release in releases:
    if not release['draft'] and release['tag_name'] == args.version:
      tag_exists = True
      break

  release = create_or_get_release_draft(github, releases, args.version,
                                        tag_exists)

  if args.publish_release:
    # Upload the Node SHASUMS*.txt.
    run_python_script('upload-node-checksums.py', '-v', ELECTRON_VERSION)

    # Upload the index.json.
    run_python_script('upload-index-json.py')

    # Create and upload the Electron SHASUMS*.txt
    release_electron_checksums(github, release)

    # Press the publish button.
    publish_release(github, release['id'])

    # Do not upload other files when passed "-p".
    return

  # Upload Electron with GitHub Releases API.
  upload_electron(github, release, os.path.join(DIST_DIR, DIST_NAME))
  upload_electron(github, release, os.path.join(DIST_DIR, SYMBOLS_NAME))
  if PLATFORM == 'darwin':
    upload_electron(github, release, os.path.join(DIST_DIR,
                    'electron-api.json'))
    upload_electron(github, release, os.path.join(DIST_DIR, 'electron.d.ts'))
    upload_electron(github, release, os.path.join(DIST_DIR, DSYM_NAME))
  elif PLATFORM == 'win32':
    upload_electron(github, release, os.path.join(DIST_DIR, PDB_NAME))

  # Upload free version of ffmpeg.
  ffmpeg = get_zip_name('ffmpeg', ELECTRON_VERSION)
  upload_electron(github, release, os.path.join(DIST_DIR, ffmpeg))

  # Upload chromedriver and mksnapshot for minor version update.
  if parse_version(args.version)[2] == '0':
    chromedriver = get_zip_name('chromedriver', ELECTRON_VERSION)
    upload_electron(github, release, os.path.join(DIST_DIR, chromedriver))
    mksnapshot = get_zip_name('mksnapshot', ELECTRON_VERSION)
    upload_electron(github, release, os.path.join(DIST_DIR, mksnapshot))

  if PLATFORM == 'win32' and not tag_exists:
    # Upload PDBs to Windows symbol server.
    run_python_script('upload-windows-pdb.py')

    # Upload node headers.
    run_python_script('upload-node-headers.py', '-v', args.version)