def _main(arg_strings=None):
    parser = _make_parser()
    args = parser.parse_args(arg_strings)
    version_name = "open-ce-v{}".format(args.version)
    release_number = ".".join(args.version.split(".")[:-1])
    branch_name = "open-ce-r{}".format(release_number)
    primary_repo_url = "[email protected]:{}/{}.git".format(
        args.github_org, args.primary_repo)

    version_msg = "Open-CE Version {}".format(args.version)
    release_name = "v{}".format(args.version)
    if args.code_name:
        version_msg = "{} Code-named {}".format(version_msg, args.code_name)
        release_name = "{} ({})".format(release_name, args.code_name)

    primary_repo_path = os.path.abspath(
        os.path.join(args.repo_dir, args.primary_repo))
    print("--->Making clone location: " + primary_repo_path)
    os.makedirs(primary_repo_path, exist_ok=True)
    print("--->Cloning {}".format(primary_repo_url))
    git_utils.clone_repo(primary_repo_url, primary_repo_path, args.branch)

    print("--->Creating {} branch in {}".format(version_name,
                                                args.primary_repo))
    git_utils.create_branch(primary_repo_path, branch_name)

    print("--->Updating env files.")
    _update_env_files(primary_repo_path, version_name)

    print("--->Committing env files.")
    git_utils.commit_changes(primary_repo_path,
                             "Updates for {}".format(release_number))

    print("--->Tag Primary Branch")
    git_utils.create_tag(primary_repo_path, version_name, version_msg)

    push = git_utils.ask_for_input(
        "Would you like to push changes to primary repo?")
    if push.startswith("y"):
        print("--->Pushing branch.")
        git_utils.push_branch(primary_repo_path, branch_name)
        print("--->Pushing tag.")
        git_utils.push_branch(primary_repo_path, version_name)

    tag_all_repos.tag_all_repos(github_org=args.github_org,
                                tag=version_name,
                                tag_msg=version_msg,
                                branch=args.branch,
                                repo_dir=args.repo_dir,
                                pat=args.pat,
                                skipped_repos=[args.primary_repo, ".github"] +
                                inputs.parse_arg_list(args.skipped_repos),
                                prev_tag=None)

    release = git_utils.ask_for_input(
        "Would you like to create a github release?")
    if release.startswith("y"):
        print("--->Creating Draft Release.")
        git_utils.create_release(args.github_org, args.primary_repo, args.pat,
                                 version_name, release_name, version_msg, True)
Beispiel #2
0
def _main(arg_strings=None):  # pylint: disable=too-many-locals, too-many-statements
    parser = _make_parser()
    args = parser.parse_args(arg_strings)

    config_file = None
    if args.conda_build_configs:
        config_file = os.path.abspath(args.conda_build_configs)

    primary_repo_path = "./"

    open_ce_env_file = os.path.abspath(
        os.path.join(primary_repo_path, "envs", "opence-env.yaml"))
    if not _has_git_tag_changed(primary_repo_path, args.branch,
                                open_ce_env_file):
        print("--->The opence-env git_tag has not changed.")
        print("--->No release is needed.")
        return
    print("--->The opence-env git_tag has changed!")
    current_tag = _get_git_tag_from_env_file(open_ce_env_file)
    previous_tag = _get_previous_git_tag_from_env_file(primary_repo_path,
                                                       args.branch,
                                                       open_ce_env_file)
    version = _git_tag_to_version(current_tag)
    release_number = ".".join(version.split(".")[:-1])
    bug_fix = version.split(".")[-1]
    branch_name = "open-ce-r{}".format(release_number)
    version_msg = "Open-CE Version {}".format(version)
    release_name = "v{}".format(version)

    env_file_contents = env_config.load_env_config_files([open_ce_env_file],
                                                         utils.ALL_VARIANTS(),
                                                         ignore_urls=True)
    for env_file_content in env_file_contents:
        env_file_tag = env_file_content.get(
            env_config.Key.git_tag_for_env.name, None)
        if env_file_tag != current_tag:
            message = "Incorrect {} '{}' found in the following env_file:\n{}".format(
                env_config.Key.git_tag_for_env.name, env_file_tag,
                env_file_content)
            raise Exception(message)

    if not git_utils.branch_exists(primary_repo_path, branch_name):
        print("--->Creating {} branch in {}".format(branch_name,
                                                    args.primary_repo))
        git_utils.create_branch(primary_repo_path, branch_name)
    else:
        print("--->Branch {} already exists in {}. Not creating it.".format(
            current_tag, args.primary_repo))

    print("--->Tag Primary Branch")
    git_utils.create_tag(primary_repo_path, current_tag, version_msg)

    if args.not_dry_run:
        print("--->Pushing branch.")
        git_utils.push_branch(primary_repo_path, branch_name)
        print("--->Pushing tag.")
        git_utils.push_branch(primary_repo_path, current_tag)
    else:
        print("--->Skipping pushing branch and tag for dry run.")

    repos = _get_all_feedstocks(env_files=env_file_contents,
                                github_org=args.github_org,
                                pat=args.pat,
                                skipped_repos=[args.primary_repo, ".github"] +
                                inputs.parse_arg_list(args.skipped_repos))

    repos.sort(key=lambda repo: repo["name"])

    tag_all_repos.clone_repos(repos=repos,
                              branch=None,
                              repo_dir=args.repo_dir,
                              prev_tag=previous_tag)
    tag_all_repos.tag_repos(repos=repos,
                            tag=current_tag,
                            tag_msg=version_msg,
                            repo_dir=args.repo_dir)
    if args.not_dry_run:
        tag_all_repos.push_repos(repos=repos,
                                 tag=current_tag,
                                 repo_dir=args.repo_dir,
                                 continue_query=False)
    else:
        print("--->Skipping pushing feedstocks for dry run.")

    print("--->Generating Release Notes.")
    release_notes = _create_release_notes(
        repos,
        version,
        release_number,
        bug_fix,
        current_tag,
        previous_tag,
        utils.ALL_VARIANTS(),
        config_file,
        repo_dir=args.repo_dir,
    )
    print(release_notes)

    if args.not_dry_run:
        print("--->Creating Draft Release.")
        git_utils.create_release(args.github_org, args.primary_repo, args.pat,
                                 current_tag, release_name, release_notes,
                                 True)
    else:
        print("--->Skipping release creation for dry run.")