def main(args: argparse.Namespace) -> None: check_path() rel = version.LooseVersion(args.release) print("Release:", rel) if len(rel.version) == 3: # Major release major, minor, patch = version.StrictVersion(args.release).version rc = None rc_ver = None else: # RC release major, minor, patch, rc, rc_ver = cast(Tuple[int, int, int, str, int], rel.version) assert rc == "rc" release = str(major) + "." + str(minor) + "." + str(patch) branch = "release_" + release git.clean("-xdf") git.checkout(branch) git.pull("origin", branch) git.submodule("update") commit_hash = latest_hash() download_r_packages(release, "" if rc is None else rc + str(rc_ver), commit_hash) download_py_packages(major, minor, commit_hash)
def main(args: argparse.Namespace) -> None: check_path() rel = version.StrictVersion(args.release) platforms = [ "win_amd64", "manylinux2010_x86_64", "manylinux2014_aarch64", "macosx_10_14_x86_64.macosx_10_15_x86_64.macosx_11_0_x86_64", ] print("Release:", rel) major, minor, patch = rel.version branch = "release_" + str(major) + "." + str(minor) + ".0" git.clean("-xdf") git.checkout(branch) git.pull("origin", branch) git.submodule("update") commit_hash = lastest_hash() dir_URL = PREFIX + str(major) + "." + str(minor) + ".0" + "/" src_filename_prefix = "xgboost-" + args.release + "%2B" + commit_hash + "-py3-none-" target_filename_prefix = "xgboost-" + args.release + "-py3-none-" if not os.path.exists(DIST): os.mkdir(DIST) filenames = download_wheels(platforms, dir_URL, src_filename_prefix, target_filename_prefix) print("List of downloaded wheels:", filenames) print(""" Following steps should be done manually: - Generate source package by running `python setup.py sdist`. - Upload pypi package by `python3 -m twine upload dist/<Package Name>` for all wheels. - Check the uploaded files on `https://pypi.org/project/xgboost/<VERSION>/#files` and `pip install xgboost==<VERSION>` """)
def finish(name): """ USAGE git-finish [-n/--name= <name>] DESCRIPTION Set the current branch's upstream to point to old, then rename it, substituting the "feature" prefix for "old", so it no longer appears in "git features". """ buf = StringIO() if not name: name = str(git.branch("--show-current")).strip() if re.match("^feature/", name): new_name = re.sub("^feature", "finished", name) click.echo(f"Finishing {name} by renaming it to {new_name}") try: git.branch(u="old", _err_to_out=True, _out=buf) git.branch("-m", name, new_name, _err_to_out=True, _out=buf) git.checkout("master") except sh.ErrorReturnCode: click.echo("Something went wrong!") click.echo(buf.getvalue()) return 1 else: click.echo('Branch name does not start with "feature/"') return 1 return 0
def clone_commit(cirpy_dir, commit): """ Clones the `circuitpython` repository, fetches the commit, then checks out the repo at that ref. """ working_dir = pathlib.Path() rosiepi_logger.info("Cloning repository at reference: %s", commit) try: git.clone("--depth", "1", "-n", "https://github.com/sommersoft/circuitpython.git", cirpy_dir) os.chdir(cirpy_dir) git.fetch("origin", commit) git.checkout(commit) git.submodule("sync") git.submodule("update", "--init") except sh.ErrorReturnCode as git_err: git_stderr = str(git_err.stderr, encoding="utf-8").strip("\n") err_msg = [ f"Failed to retrive repository at {commit}:", f" - {git_stderr}", ] rosiepi_logger.warning("%s", "\n".join(err_msg)) raise RuntimeError(git_stderr) from None finally: os.chdir(working_dir)
def fix_head_for_github( base_commit_ref: Optional[str] = None, head_ref: Optional[str] = None, ) -> Iterator[Optional[str]]: """ GHA can checkout the incorrect commit for a PR (it will create a fake merge commit), so we need to reset the head to the actual PR branch head before continuing. Note that this code is written in a generic manner, so that it becomes a no-op when the CI system has not artifically altered the HEAD ref. :return: The baseline ref as a commit hash """ stashed_rev: Optional[str] = None base_ref: Optional[str] = base_commit_ref if get_git_repo() is None: yield base_ref return if base_ref: # Preserve location of head^ after we possibly change location below base_ref = git(["rev-parse", base_ref]).stdout.decode("utf-8").rstrip() if head_ref: stashed_rev = git(["branch", "--show-current"]).stdout.decode("utf-8").rstrip() if not stashed_rev: stashed_rev = git(["rev-parse", "HEAD"]).stdout.decode("utf-8").rstrip() click.echo(f"| not on head ref {head_ref}; checking that out now...", err=True) git.checkout([head_ref]) try: if base_ref is not None: merge_base = git("merge-base", base_ref, "HEAD").rstrip() # fmt:off click.echo("| reporting findings introduced by these commits:", err=True) print_git_log(f"{merge_base}..HEAD") if merge_base != git("rev-parse", base_ref).rstrip(): click.echo( "| also reporting findings fixed by these commits from the baseline branch:", err=True) print_git_log(f"{merge_base}..{base_ref}") click.echo("| to exclude these latter commits, run with", err=True) click.echo( f"| --baseline-ref $(git merge-base {base_commit_ref} HEAD)", err=True) # fmt: on yield base_ref finally: if stashed_rev is not None: click.echo(f"| returning to original head revision {stashed_rev}", err=True) git.checkout([stashed_rev])
def test_watch(monkeypatch): # XXX TODO: expand def wrap_watch(pattern, force=False): cmd = 'watch{0}'.format('-force' if force else '') msg = Fake({ "_client": { "host": "stackexchange.com", "get_user": lambda id: Fake({ "name": "J F", "id": id }) }, "owner": { "name": "El'endia Starman", "id": 1 }, "room": { "id": 11540, "get_current_user_ids": lambda: [161943] }, # Ouch, this is iffy # Prevent an error from deep inside do_blacklist "content_source": '!!/{0} {1}'.format(cmd, pattern) }) msg.room._client = msg._client return chatcommands.watch(pattern, alias_used=cmd, original_msg=msg) # Prevent from attempting to check privileges with Metasmoke monkeypatch.setattr(GlobalVars, "code_privileged_users", [1, 161943]) try: # Invalid regex resp = wrap_watch(r'?') assert "An invalid pattern was provided" in resp # This is one of the perpetually condemned spam domains, blacklisted forever resp = wrap_watch(r'israelbigmarket') assert "That pattern looks like it's already caught" in resp # The phone number here is the first one in this format in bad_keywords.txt resp = wrap_watch(r'[a-z_]*(?:1_*)?913[\W_]*608[\W_]*4584[a-z_]*') assert "Mostly non-latin" not in resp assert "Bad keyword in answer" in resp assert "Bad keyword in body" in resp # XXX TODO: figure out how to trigger duplicate entry separately monkeypatch.setattr("chatcommunicate.is_privileged", lambda *args: True) monkeypatch.setattr("gitmanager.GitManager.prepare_git_for_operation", lambda *args: (True, None)) assert wrap_watch("trimfire", True).startswith("Already watched") monkeypatch.setattr("gitmanager.GitManager.add_to_blacklist", lambda *args, **kwargs: (True, "Hahaha")) assert wrap_watch("male enhancement", True) == "Hahaha" finally: git.checkout("master")
def pull_update(): # Force pull update try: git.branch('-D', 'temp') except GitError: pass git.checkout('-b', 'temp', "origin/deploy") git.branch('-M', 'deploy') os._exit(0)
def _cut_stable_release(layer_list, charm_list, ancillary_list, filter_by_tag, dry_run): """This will merge each layers master onto the stable branches. PLEASE NOTE: This step should come after each stable branch has been tagged and references a current stable bundle revision. layer_list: YAML spec containing git repos and their upstream/downstream properties charm_list: YAML spec containing git repos and their upstream/downstream properties """ layer_list = yaml.safe_load(Path(layer_list).read_text(encoding="utf8")) charm_list = yaml.safe_load(Path(charm_list).read_text(encoding="utf8")) ancillary_list = yaml.safe_load( Path(ancillary_list).read_text(encoding="utf8")) new_env = os.environ.copy() for layer_map in layer_list + charm_list + ancillary_list: for layer_name, repos in layer_map.items(): downstream = repos["downstream"] if not repos.get("needs_stable", True): continue tags = repos.get("tags", None) if tags: if not any(match in filter_by_tag for match in tags): continue log.info( f"Releasing :: {layer_name:^35} :: from: master to: stable") if not dry_run: downstream = f"https://{new_env['CDKBOT_GH_USR']}:{new_env['CDKBOT_GH_PSW']}@github.com/{downstream}" identifier = str(uuid.uuid4()) os.makedirs(identifier) for line in git.clone(downstream, identifier, _iter=True): log.info(line) git_rev_master = git("rev-parse", "origin/master", _cwd=identifier).stdout.decode() git_rev_stable = git("rev-parse", "origin/stable", _cwd=identifier).stdout.decode() if git_rev_master == git_rev_stable: log.info( f"Skipping :: {layer_name:^35} :: master == stable") continue git.config("user.email", "*****@*****.**", _cwd=identifier) git.config("user.name", "cdkbot", _cwd=identifier) git.config("--global", "push.default", "simple") git.checkout("-f", "stable", _cwd=identifier) git.merge("master", "--no-ff", _cwd=identifier) for line in git.push("origin", "stable", _cwd=identifier, _iter=True): log.info(line)
def _baseline_context(self) -> Iterator[None]: """ Runs a block of code on files from the current branch HEAD. :raises ActionFailure: If git cannot detect a HEAD commit :raises ActionFailure: If unmerged files are detected """ repo = get_git_repo() if not repo: yield return self._abort_on_pending_changes() self._abort_on_conflicting_untracked_paths() current_tree = git("write-tree").stdout.decode().strip() try: for a in self._status.added: a.unlink() git.checkout(self._base_commit, "--", ".") yield finally: # git checkout will fail if the checked-out index deletes all files in the repo # In this case, we still want to continue without error. # Note that we have no good way of detecting this issue without inspecting the checkout output # message, which means we are fragile with respect to git version here. try: git.checkout(current_tree.strip(), "--", ".") except sh.ErrorReturnCode as error: output = error.stderr.decode() if (output and len(output) >= 2 and "pathspec '.' did not match any file(s) known to git" in output.strip()): debug_echo( "Restoring git index failed due to total repository deletion; skipping checkout" ) else: raise ActionFailure( f"Fatal error restoring Git state; please restore your repository state manually:\n{output}" ) if self._status.removed: # Need to check if file exists since it is possible file was deleted # in both the base and head. Only call if there are files to delete to_remove = [r for r in self._status.removed if r.exists()] if to_remove: git.rm("-f", *(str(r) for r in to_remove))
def pull_layers(self): """ clone all downstream layers to be processed locally when doing charm builds """ if self.rebuild_cache: click.echo("- rebuild cache triggered, cleaning out cache.") shutil.rmtree(str(self.layers_dir)) shutil.rmtree(str(self.interfaces_dir)) os.mkdir(str(self.layers_dir)) os.mkdir(str(self.interfaces_dir)) layers_to_pull = [] for layer_map in self.layers: layer_name = list(layer_map.keys())[0] if layer_name == "layer:index": continue layers_to_pull.append(layer_name) pool = ThreadPool() pool.map(self.download, layers_to_pull) self.db["pull_layer_manifest"] = [] _paths_to_process = { "layer": glob("{}/*".format(str(self.layers_dir))), "interface": glob("{}/*".format(str(self.interfaces_dir))), } for prefix, paths in _paths_to_process.items(): for _path in paths: build_path = _path if not build_path: raise BuildException( f"Could not determine build path for {_path}") git.checkout(self.layer_branch, _cwd=build_path) layer_manifest = { "rev": git("rev-parse", "HEAD", _cwd=build_path).stdout.decode().strip(), "url": f"{prefix}:{Path(build_path).stem}", } self.db["pull_layer_manifest"].append(layer_manifest) click.echo( f"- {layer_manifest['url']} at commit: {layer_manifest['rev']}" )
def test_watch(monkeypatch): # XXX TODO: expand def wrap_watch(pattern, force=False): cmd = 'watch{0}'.format('-force' if force else '') msg = Fake({ "_client": { "host": "stackexchange.com", "get_user": lambda id: Fake({"name": "J F", "id": id}) }, "owner": {"name": "ArtOfCode", "id": 121520}, "room": {"id": 11540, "get_current_user_ids": lambda: [161943]}, # Ouch, this is iffy # Prevent an error from deep inside do_blacklist "content_source": '!!/{0} {1}'.format(cmd, pattern) }) msg.room._client = msg._client return chatcommands.watch(pattern, alias_used=cmd, original_msg=msg) # Prevent from attempting to check privileges with Metasmoke monkeypatch.setattr(GlobalVars, "code_privileged_users", [1, 161943]) try: # Invalid regex resp = wrap_watch(r'?') assert "An invalid pattern was provided" in resp # This is one of the perpetually condemned spam domains, blacklisted forever resp = wrap_watch(r'israelbigmarket') assert "That pattern looks like it's already caught" in resp # The phone number here is the first one in this format in bad_keywords.txt resp = wrap_watch(r'[a-z_]*(?:1_*)?913[\W_]*608[\W_]*4584[a-z_]*') assert "Mostly non-latin" not in resp assert "Bad keyword in answer" in resp assert "Bad keyword in body" in resp # XXX TODO: figure out how to trigger duplicate entry separately monkeypatch.setattr("chatcommunicate.is_privileged", lambda *args: True) monkeypatch.setattr("gitmanager.GitManager.prepare_git_for_operation", lambda *args: (True, None)) assert wrap_watch("trimfire", True).startswith("Already watched") monkeypatch.setattr("gitmanager.GitManager.add_to_blacklist", lambda *args, **kwargs: (True, "Hahaha")) assert wrap_watch("male enhancement", True) == "Hahaha" finally: git.checkout("master")
def _baseline_context(self) -> Iterator[None]: """ Runs a block of code on files from the current branch HEAD. :raises RuntimeError: If git cannot detect a HEAD commit :raises RuntimeError: If unmerged files are detected """ repo = get_git_repo() if not repo: yield return self._abort_if_dirty() current_tree = git("write-tree").stdout.decode().strip() try: for a in self._status.added: a.unlink() git.checkout(self._base_commit, "--", ".") yield finally: # git checkout will fail if the checked-out index deletes all files in the repo # In this case, we still want to continue without error. # Note that we have no good way of detecting this issue without inspecting the checkout output # message, which means we are fragile with respect to git version here. try: git.checkout(current_tree.strip(), "--", ".") except sh.ErrorReturnCode as error: output = error.stderr.decode() if (output and len(output) >= 2 and "pathspec '.' did not match any file(s) known to git" in output.strip()): debug_echo( "Restoring git index failed due to total repository deletion; skipping checkout" ) else: raise error if self._status.removed: git.rm("-f", *(str(r) for r in self._status.removed))
def feature(ticket, project_directory, name): """ USAGE git-feature <ticket> <project folder> <name> DESCRIPTION Create a new GIT branch, tracking master, and setting upstream, named following the pattern 'feature/<ticket>__<project folder>__<name>'. Other git-tools tools will look for names following this pattern. Spaces in <name> will be replaced with dashes. """ name__interspersed_dashes = "-".join(re.split(r"\s+", name)) br_name = f"feature/{ticket}__{project_directory}__{name__interspersed_dashes}" click.echo(f"Calling git-feature to create {br_name}") try: print(git.checkout("master", _err_to_out=True)) print(sh.jira.view(ticket)) print(git.checkout("-t", "-b", br_name, _err_to_out=True)) print(git.branch("--set-upstream-to=master", _err_to_out=True)) except sh.ErrorReturnCode as e: click.echo(f"Something went wrong!\n\nException: {e}") return 1 return 0
def main(args: argparse.Namespace) -> None: check_path() rel = version.parse(args.release) assert isinstance(rel, version.Version) major = rel.major minor = rel.minor patch = rel.micro print("Release:", rel) if not rel.is_prerelease: # Major release rc: Optional[str] = None rc_ver: Optional[int] = None else: # RC release major = rel.major minor = rel.minor patch = rel.micro assert rel.pre is not None rc, rc_ver = rel.pre assert rc == "rc" release = str(major) + "." + str(minor) + "." + str(patch) branch = "release_" + release git.clean("-xdf") git.checkout(branch) git.pull("origin", branch) git.submodule("update") commit_hash = latest_hash() download_r_packages( release, "" if rc is None else rc + str(rc_ver), commit_hash ) download_py_packages(major, minor, commit_hash)
def _fix_head_for_github( base_ref_name: Optional[str] = None, head_ref: Optional[str] = None, ) -> Iterator[Optional[str]]: """ GHA can checkout the incorrect commit for a PR (it will create a fake merge commit), so we need to reset the head to the actual PR branch head before continuing. Note that this code is written in a generic manner, so that it becomes a no-op when the CI system has not artifically altered the HEAD ref. :return: The baseline ref as a commit hash """ debug_echo( f"Called _fix_head_for_github with base_ref_name: {base_ref_name} head_ref: {head_ref}" ) stashed_rev: Optional[str] = None base_ref: Optional[str] = base_ref_name if get_git_repo() is None: debug_echo("Yielding base_ref since get_git_repo was None") yield base_ref return if base_ref: # Preserve location of head^ after we possibly change location below try: debug_echo(f"Calling git rev-parse {base_ref}") process = git(["rev-parse", base_ref]) base_ref = process.stdout.decode("utf-8").rstrip() except sh.ErrorReturnCode as ex: raise ActionFailure( f"There is a problem with your git project:{ex}") if head_ref: debug_echo("Calling git branch --show-current") stashed_rev = git(["branch", "--show-current"]).stdout.decode("utf-8").rstrip() debug_echo(f"stashed_rev: {stashed_rev}") if not stashed_rev: debug_echo("Calling git rev-parse HEAD") rev_parse = git(["rev-parse", "HEAD"]) debug_echo(rev_parse.stderr.decode("utf-8").rstrip()) stashed_rev = rev_parse.stdout.decode("utf-8").rstrip() debug_echo(f"stashed_rev: {stashed_rev}") click.echo(f"| not on head ref {head_ref}; checking that out now...", err=True) git.checkout([head_ref], _timeout=GIT_SH_TIMEOUT, _out=debug_echo, _err=debug_echo) debug_echo(f"checked out {head_ref}") try: if base_ref is not None: merge_base = git("merge-base", base_ref, "HEAD").rstrip() # fmt:off click.echo("| reporting findings introduced by these commits:", err=True) print_git_log(f"{merge_base}..HEAD") if merge_base != git("rev-parse", base_ref).rstrip(): click.echo( "| also reporting findings fixed by these commits from the baseline branch:", err=True) print_git_log(f"{merge_base}..{base_ref}") click.echo("| to exclude these latter commits, run with", err=True) click.echo( f"| --baseline-ref $(git merge-base {base_ref_name} HEAD)", err=True) # fmt: on debug_echo(f"yielding {base_ref}") yield base_ref finally: if stashed_rev is not None: click.echo(f"| returning to original head revision {stashed_rev}", err=True) git.checkout([stashed_rev], _timeout=GIT_SH_TIMEOUT)
def _tag_stable_forks(layer_list, charm_list, k8s_version, bundle_rev, filter_by_tag, bugfix, dry_run): """Tags stable forks to a certain bundle revision for a k8s version layer_list: YAML spec containing git repos and their upstream/downstream properties bundle_rev: bundle revision to tag for a particular version of k8s git tag (ie. ck-{bundle_rev}), this would mean we tagged current stable branches for 1.14 with the latest charmed kubernetes(ck) bundle rev of {bundle_rev} TODO: Switch to different merge strategy git checkout master git checkout -b staging git merge stable -s ours git checkout stable git reset staging """ layer_list = yaml.safe_load(Path(layer_list).read_text(encoding="utf8")) charm_list = yaml.safe_load(Path(charm_list).read_text(encoding="utf8")) new_env = os.environ.copy() for layer_map in layer_list + charm_list: for layer_name, repos in layer_map.items(): tags = repos.get("tags", None) if tags: if not any(match in filter_by_tag for match in tags): continue downstream = repos["downstream"] if bugfix: tag = f"{k8s_version}+{bundle_rev}" else: tag = f"ck-{k8s_version}-{bundle_rev}" if not repos.get("needs_tagging", True): log.info(f"Skipping {layer_name} :: does not require tagging") continue log.info(f"Tagging {layer_name} ({tag}) :: {repos['downstream']}") if not dry_run: downstream = f"https://{new_env['CDKBOT_GH_USR']}:{new_env['CDKBOT_GH_PSW']}@github.com/{downstream}" identifier = str(uuid.uuid4()) os.makedirs(identifier) for line in git.clone(downstream, identifier, _iter=True): log.info(line) git.config("user.email", "*****@*****.**", _cwd=identifier) git.config("user.name", "cdkbot", _cwd=identifier) git.config("--global", "push.default", "simple") git.checkout("stable", _cwd=identifier) try: for line in git.tag("--force", tag, _cwd=identifier, _iter=True, _bg_exc=False): log.info(line) for line in git.push( "--force", "origin", tag, _cwd=identifier, _bg_exc=False, _iter=True, ): log.info(line) except sh.ErrorReturnCode as error: log.info( f"Problem tagging: {error.stderr.decode().strip()}, will skip for now.." )
def build_fw(board, build_ref, test_log): # pylint: disable=too-many-locals,too-many-statements """ Builds the firware at `build_ref` for `board`. Firmware will be output to `.fw_builds/<build_ref>/<board>/`. :param: str board: Name of the board to build firmware for. :param: str build_ref: The tag/commit to build firmware for. :param: test_log: The TestController.log used for output. """ working_dir = os.getcwd() cirpy_ports_dir = pathlib.Path(cirpy_dir(), "ports") board_port_dir = None for port in _AVAILABLE_PORTS: port_dir = cirpy_ports_dir / port / "boards" / board if port_dir.exists(): board_port_dir = (cirpy_ports_dir / port).resolve() rosiepi_logger.info("Board source found: %s", board_port_dir) break if board_port_dir is None: err_msg = [ f"'{board}' board not available to test. Can't build firmware.", #"="*60, #"Closing RosiePi" ] raise RuntimeError("\n".join(err_msg)) build_dir = pathlib.Path.home() / ".fw_builds" / build_ref[:5] / board os.chdir(cirpy_dir()) try: test_log.write("Fetching {}...".format(build_ref)) git.fetch("--depth", "1", "origin", build_ref) test_log.write("Checking out {}...".format(build_ref)) git.checkout(build_ref) test_log.write("Syncing submodules...") git.submodule("sync") test_log.write("Updating submodules...") git.submodule("update", "--init", "--depth", "1") except sh.ErrorReturnCode as git_err: # TODO: change to 'master' git.checkout("-f", "rosiepi_test") os.chdir(working_dir) err_msg = [ "Building firmware failed:", " - {}".format(str(git_err.stderr, encoding="utf-8").strip("\n")), #"="*60, #"Closing RosiePi" ] raise RuntimeError("\n".join(err_msg)) from None os.chdir(board_port_dir) board_cmd = (f"make clean BOARD={board} BUILD={build_dir}", f"make BOARD={board} BUILD={build_dir}") test_log.write("Building firmware...") try: rosiepi_logger.info("Running make recipe: %s", '; '.join(board_cmd)) run_envs = { "BASH_ENV": "/etc/profile", } rosiepi_logger.info("Running build clean...") # pylint: disable=subprocess-run-check subprocess.run( board_cmd[0], shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, executable="/usr/bin/bash", start_new_session=True, env=run_envs, ) build_dir.mkdir(mode=0o0774, parents=True) # pylint: enable=subprocess-run-check rosiepi_logger.info("Running firmware build...") fw_build = subprocess.run( board_cmd[1], check=True, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, executable="/usr/bin/bash", start_new_session=True, env=run_envs, ) result = str(fw_build.stdout, encoding="utf-8").split("\n") success_msg = [line for line in result if "bytes" in line] test_log.write(" - " + "\n - ".join(success_msg)) rosiepi_logger.info("Firmware built...") except subprocess.CalledProcessError as cmd_err: # TODO: change to 'master' git.checkout("-f", "rosiepi_test") os.chdir(working_dir) err_msg = [ "Building firmware failed:", " - {}".format(str(cmd_err.stdout, encoding="utf-8").strip("\n")), #"="*60, #"Closing RosiePi" ] rosiepi_logger.warning("Firmware build failed...") raise RuntimeError("\n".join(err_msg)) from None finally: # TODO: change to 'master' git.checkout("-f", "rosiepi_test") os.chdir(working_dir) return build_dir
parser.add_argument('--configure', help='re-configure the build', action='store_true') args = parser.parse_args() # --- install the source code if args.gitclone: print "git clone the source code" # use 1.1.4, not latest and not 1.2, until told otherwise rm('-fr', 'libtorrent') git.clone('https://github.com/arvidn/libtorrent.git') cd('libtorrent') git.checkout('RC_1_1') # gets 1.1.4 <<----- DO THIS else: # ensure cd to libtorrent cd('libtorrent') # --- configure if args.configure: print "configure" cmd = sh.Command('./autotool.sh') cmd() configure = sh.Command("./configure") configure('--libdir=/usr/lib/i386-linux-gnu/', 'LDFLAGS=-L/usr/local/lib/', "--with-boost-libdir=/usr/lib/i386-linux-gnu/", "--enable-encryption", "--prefix=/usr/local/", "--disable-debug",
def _cut_stable_release(layer_list, charm_list, ancillary_list, filter_by_tag, dry_run): """This will merge each layers master onto the stable branches. PLEASE NOTE: This step should come after each stable branch has been tagged and references a current stable bundle revision. layer_list: YAML spec containing git repos and their upstream/downstream properties charm_list: YAML spec containing git repos and their upstream/downstream properties """ layer_list = yaml.safe_load(Path(layer_list).read_text(encoding="utf8")) charm_list = yaml.safe_load(Path(charm_list).read_text(encoding="utf8")) ancillary_list = yaml.safe_load( Path(ancillary_list).read_text(encoding="utf8")) new_env = os.environ.copy() failed_to_release = [] for layer_map in layer_list + charm_list + ancillary_list: for layer_name, repos in layer_map.items(): downstream = repos["downstream"] if not repos.get("needs_stable", True): continue tags = repos.get("tags", None) if tags: if not any(match in filter_by_tag for match in tags): continue auth = (new_env.get("CDKBOT_GH_USR"), new_env.get("CDKBOT_GH_PSW")) default_branch = repos.get("branch") or default_gh_branch( downstream, auth=auth) log.info( f"Releasing :: {layer_name:^35} :: from: {default_branch} to: stable" ) downstream = f"https://{':'.join(auth)}@github.com/{downstream}" identifier = str(uuid.uuid4()) os.makedirs(identifier) for line in git.clone(downstream, identifier, _iter=True): log.info(line) git_rev_default = (git("rev-parse", f"origin/{default_branch}", _cwd=identifier).stdout.decode().strip()) git_rev_stable = (git("rev-parse", "origin/stable", _cwd=identifier).stdout.decode().strip()) if git_rev_default == git_rev_stable: log.info( f"Skipping :: {layer_name:^35} :: {default_branch} == stable" ) continue log.info( f"Commits :: {layer_name:^35} :: {default_branch} != stable") log.info(f" {default_branch:10}= {git_rev_default:32}") log.info(f" {'stable':10}= {git_rev_stable:32}") for line in git("rev-list", f"origin/stable..origin/{default_branch}", _cwd=identifier): for line in git.show( "--format=%h %an '%s' %cr", "--no-patch", line.strip(), _cwd=identifier, ): log.info(" " + line.strip()) if not dry_run: git.config("user.email", "*****@*****.**", _cwd=identifier) git.config("user.name", "cdkbot", _cwd=identifier) git.config("--global", "push.default", "simple") git.checkout("-f", "stable", _cwd=identifier) git.reset(default_branch, _cwd=identifier) for line in git.push("origin", "stable", "-f", _cwd=identifier, _iter=True): log.info(line)