def log(_, name, range, resolve=False, verbose=False, profile=None):
"""
Show git log between versions and/or commits.
This resolves catapult versions (eg `v123`) into git commits, in
addition to anything that git can map to a single commit, eg
`fc20299e`, `my_branch`, `some_tag`.
"""
repo = utils.git_repo()
client = utils.s3_client(profile)
lx, _, rx = range.partition("..")
def resolve_range(ref):
if ref.startswith("v") and ref[1:].isdigit():
release = get_release(client, name, int(ref[1:]))
ref = release.commit
return utils.revparse(repo, ref)
start = resolve_range(lx)
end = resolve_range(rx)
if resolve:
text = f"{start.hex}...{end.hex}"
else:
changelog = utils.changelog(repo, end, start)
text = changelog.text if verbose else changelog.short_text
print(text)
def log(_, name, git_range, resolve=False):
"""
Search a release from the commit hash.
"""
repo = utils.git_repo()
client = utils.s3_client()
lx, _, rx = git_range.partition("..")
def resolve_range(ref):
if ref.startswith("v") and ref[1:].isdigit():
release = get_release(client, name, int(ref[1:]))
return release.commit
return ref
start = resolve_range(lx)
end = resolve_range(rx)
if resolve:
text = f"{start}...{end}"
else:
text = utils.changelog(repo, end, start).text
print(text)
def start(
_,
name,
env,
version=None,
bucket=None,
dry=False,
yes=False,
rollback=False,
profile=None,
):
"""
Deploy a release on an environment.
"""
client = utils.s3_client(profile)
repo = utils.git_repo()
if version is None:
release = next(get_releases(client, name), None)
else:
release = get_release(client, name, int(version))
if release is None:
utils.fatal("Release not found")
if bucket is None:
bucket = utils.get_config()["deploy"][env]["s3_bucket"]
last_deploy = next(get_releases(client, name, bucket=bucket), None)
last_deployed_version = int(last_deploy.version) if last_deploy else 0
if version is not None:
since = min(int(version), last_deployed_version)
else:
since = last_deployed_version
releases = list(get_releases(client, name, since=since))
# the field `commits` is not present in all documents as it was introduced
# in a later version. if any of the releases doesn't track them, we'll
# skip the commit filtering to avoid not showing commits in the changelog.
if any(rel.commits is None for rel in releases):
commits = None
else:
commits = [
commit for rel in releases if rel.commits for commit in rel.commits
]
if last_deploy is None:
# first deploy is always None
changelog = utils.changelog(repo,
release.commit,
None,
keep_only_commits=commits)
changelog_text = changelog.short_text
is_rollback = release.rollback
else:
# create a changelog from the latest deploy commit
changelog = utils.changelog(
repo,
git.Oid(hex=release.commit),
git.Oid(hex=last_deploy.commit),
keep_only_commits=commits,
)
changelog_text = changelog.short_text
is_rollback = changelog.rollback
action_type = ActionType.automated if config.IS_CONCOURSE else ActionType.manual
release = dataclasses.replace(
release,
changelog=changelog_text,
timestamp=datetime.now(),
author=utils.get_author(repo, git.Oid(hex=release.commit)),
rollback=is_rollback,
action_type=action_type,
commits=commits,
)
utils.printfmt(release)
if dry:
return
if release.rollback:
commit_count = len(changelog.logs)
utils.warning(":warning: This is a rollback! :warning:\n")
utils.warning(
f":warning: You are rolling back from {name} v{last_deployed_version} to v{version} :warning:\n"
)
utils.warning(
f":warning: This will remove the above {commit_count} commits from {env} :warning:\n"
)
if not rollback:
utils.error("Missing flag --rollback\n")
utils.fatal("Aborted!")
if not yes:
if release.rollback:
ok = utils.confirm(
"Are you sure you want to start a rollback deployment?",
style=utils.TextStyle.yellow,
)
if not ok:
utils.fatal("Aborted!")
ok = utils.confirm("Are you sure you want to start this deployment?")
if not ok:
utils.fatal("Aborted!")
put_release(client, bucket, name, release)
utils.success("Started new deployment :rocket:\n")
def new(
ctx,
name,
commit=None,
version=None,
dry=False,
yes=False,
image_name=None,
image_id=None,
rollback=False,
filter_files_path=None,
profile=None,
):
"""
Create a new release.
"""
repo = utils.git_repo()
client = utils.s3_client(profile)
latest = next(get_releases(client, name), None)
latest_oid = git.Oid(hex=latest.commit) if latest else None
if commit is None:
commit = "HEAD"
commit_oid = utils.revparse(repo, commit)
if version is None:
# create next version
version = 1 if latest is None else latest.version + 1
else:
version = int(version)
if image_id is None:
image_id = _get_image_id(ctx,
commit_oid,
name=name,
image_name=image_name)
if image_id is None:
utils.fatal("Image not found")
keep_only_files = None
if filter_files_path:
with open(filter_files_path) as fp:
keep_only_files = [line.strip() for line in fp]
changelog = utils.changelog(repo,
commit_oid,
latest_oid,
keep_only_files=keep_only_files)
action_type = ActionType.automated if config.IS_CONCOURSE else ActionType.manual
release = Release(
version=version,
commit=commit_oid.hex,
changelog=changelog.short_text,
version_id="",
image=image_id,
timestamp=datetime.now(),
author=utils.get_author(repo, commit_oid),
rollback=changelog.rollback,
action_type=action_type,
commits=[commit.hex for commit in changelog.logs],
)
utils.printfmt(release)
if dry:
return
if release.rollback:
utils.warning("This is a rollback! :warning:\n")
if not rollback:
utils.warning("Missing flag --rollback\n")
utils.fatal("Aborted!")
if not yes:
if release.rollback:
ok = utils.confirm(
"Are you sure you want to create a rollback release?",
style=utils.TextStyle.yellow,
)
if not ok:
utils.fatal("Aborted!")
ok = utils.confirm("Are you sure you want to create this release?")
if not ok:
utils.fatal("Aborted!")
put_release(client, _get_bucket(), name, release)
utils.success("Created new release :tada:\n")
def new(
ctx,
name,
commit=None,
version=None,
dry=False,
yes=False,
image_name=None,
rollback=False,
):
"""
Create a new release.
"""
repo = utils.git_repo()
client = utils.s3_client()
latest = next(get_releases(client, name), None)
if commit is None:
# get last commit
commit = next(utils.git_log(repo), None)
commit = commit and commit.hex
if version is None:
# crate next version
version = 1 if latest is None else latest.version + 1
else:
version = int(version)
image_id = _get_image_id(ctx, image_name or name, commit)
if image_id is None:
LOG.critical("image ID not found")
sys.exit(1)
changelog = utils.changelog(repo, commit, latest and latest.commit)
release = Release(
version=version,
commit=commit,
changelog=changelog.text,
version_id="",
image=image_id,
timestamp=datetime.now(),
author=utils.get_author(repo),
rollback=changelog.rollback,
)
utils.printfmt(release)
if dry:
return
if release.rollback:
utils.warning("this is a rollback! :warning:\n")
if not rollback:
utils.warning("missing flag --rollback\n")
utils.error("aborted!\n")
sys.exit(1)
if not yes:
if release.rollback:
ok = utils.confirm("sure you want to start a rollback?",
style=utils.TextStyle.warning)
if not ok:
utils.error("aborted!\n")
sys.exit(1)
ok = utils.confirm("sure you want to create this release?")
if not ok:
sys.exit(1)
put_release(client,
utils.get_config()["release"]["s3_bucket"], name, release)
utils.success("created new release :tada:\n")
def start(_,
name,
env,
version=None,
bucket=None,
dry=False,
yes=False,
rollback=False):
"""
Deploy a release on an environment.
"""
client = utils.s3_client()
repo = utils.git_repo()
if version is None:
release = next(get_releases(client, name), None)
else:
release = get_release(client, name, int(version))
if release is None:
LOG.critical("Release not found")
sys.exit(1)
if bucket is None:
bucket = utils.get_config()["deploy"][env]["s3_bucket"]
last_deploy = next(get_releases(client, name, bucket=bucket), None)
if last_deploy is None:
# first deploy is always None
changelog_text = release.changelog
is_rollback = release.rollback
else:
# create a changelog from the latest deploy commit
changelog = utils.changelog(repo, release.commit, last_deploy.commit)
changelog_text = changelog.text
is_rollback = changelog.rollback
release = dataclasses.replace(
release,
changelog=changelog_text,
timestamp=datetime.now(),
author=utils.get_author(repo),
rollback=is_rollback,
)
utils.printfmt(release)
if dry:
return
if release.rollback:
utils.warning("This is a rollback! :warning:\n")
if not rollback:
utils.warning("Missing flag --rollback\n")
utils.error("Aborted!\n")
sys.exit(1)
if not yes:
if release.rollback:
ok = utils.confirm(
"Are you sure you want to start a rollback deployment?",
style=utils.TextStyle.warning,
)
if not ok:
utils.error("Aborted!\n")
sys.exit(1)
ok = utils.confirm("Are you sure you want to start this deployment?")
if not ok:
utils.error("Aborted!\n")
sys.exit(1)
put_release(client, bucket, name, release)
utils.success("Started new deployment :rocket:\n")