#!/usr/bin/env python3
"""Link your Launchpad user to github, proposing branches to LP and Github"""
from argparse import ArgumentParser
from subprocess import Popen, PIPE
import os
import sys
try:
from launchpadlib.launchpad import Launchpad
except ImportError:
print("Missing python launchpadlib dependency to create branches for you."
"Install with: sudo apt-get install python3-launchpadlib" )
sys.exit(1)
if "avoid-pep8-E402-import-not-top-of-file":
_tdir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
sys.path.insert(0, _tdir)
from cloudinit import util
DRYRUN = False
LP_TO_GIT_USER_FILE='.lp-to-git-user'
MIGRATE_BRANCH_NAME='migrate-lp-to-github'
GITHUB_PULL_URL='https://github.com/canonical/cloud-init/compare/master...{github_user}:{branch}'
GH_UPSTREAM_URL='https://github.com/canonical/cloud-init'
def error(message):
if isinstance(message, bytes):
message = message.decode('utf-8')
log('ERROR: {error}'.format(error=message))
sys.exit(1)
def log(message):
print(message)
def subp(cmd, skip=False):
prefix = 'SKIPPED: ' if skip else '$ '
log('{prefix}{command}'.format(prefix=prefix, command=' '.join(cmd)))
if skip:
return
proc = Popen(cmd, stdout=PIPE, stderr=PIPE)
out, err = proc.communicate()
if proc.returncode:
error(err if err else out)
return out.decode('utf-8')
LP_GIT_PATH_TMPL = 'git+ssh://{launchpad_user}@git.launchpad.net/'
LP_UPSTREAM_PATH_TMPL = LP_GIT_PATH_TMPL + 'cloud-init'
LP_REMOTE_PATH_TMPL = LP_GIT_PATH_TMPL + '~{launchpad_user}/cloud-init'
GITHUB_REMOTE_PATH_TMPL = 'git@github.com:{github_user}/cloud-init.git'
# Comment templates
COMMIT_MSG_TMPL = '''\
lp-to-git-users: adding {gh_username}
Mapped from {lp_username}
'''
PUBLISH_DIR='/tmp/cloud-init-lp-to-github-migration'
def get_parser():
parser = ArgumentParser(description=__doc__)
parser.add_argument(
'--dryrun', required=False, default=False, action='store_true',
help=('Run commands and review operation in dryrun mode, '
'making not changes.'))
parser.add_argument('launchpad_user', help='Your launchpad username.')
parser.add_argument('github_user', help='Your github username.')
parser.add_argument(
'--local-repo-dir', required=False, dest='repo_dir',
help=('The name of the local directory into which we clone.'
' Default: {}'.format(PUBLISH_DIR)))
parser.add_argument(
'--upstream-branch', required=False, dest='upstream',
default='origin/master',
help=('The name of remote branch target into which we will merge.'
' Default: origin/master'))
parser.add_argument(
'-v', '--verbose', required=False, default=False, action='store_true',
help=('Print all actions.'))
return parser
def create_publish_branch(upstream, publish_branch):
'''Create clean publish branch target in the current git repo.'''
branches = subp(['git', 'branch'])
upstream_remote, upstream_branch = upstream.split('/', 1)
subp(['git', 'checkout', upstream_branch])
subp(['git', 'pull'])
if publish_branch in branches:
subp(['git', 'branch', '-D', publish_branch])
subp(['git', 'checkout', upstream, '-b', publish_branch])
def add_lp_and_github_remotes(lp_user, gh_user):
"""Add lp and github remotes if not present.
@return Tuple with (lp_remote_name, gh_remote_name)
"""
lp_remote = LP_REMOTE_PATH_TMPL.format(launchpad_user=lp_user)
gh_remote = GITHUB_REMOTE_PATH_TMPL.format(github_user=gh_user)
remotes = subp(['git', 'remote', '-v'])
lp_remote_name = gh_remote_name = None
for remote in remotes.splitlines():
if not remote:
continue
remote_name, remote_url, _operation = remote.split()
if lp_remote == remote_url:
lp_remote_name = remote_name
elif gh_remote == remote_url:
gh_remote_name = remote_name
if not lp_remote_name:
log("launchpad: Creating git remote launchpad-{} to point at your"
" LP repo".format(lp_user))
lp_remote_name = 'launchpad-{}'.format(lp_user)
subp(['git', 'remote', 'add', lp_remote_name, lp_remote])
try:
subp(['git', 'fetch', lp_remote_name])
except:
log("launchpad: Pushing to ensure LP repo exists")
subp(['git', 'push', lp_remote_name, 'master:master'])
subp(['git', 'fetch', lp_remote_name])
if not gh_remote_name:
log("github: Creating git remote github-{} to point at your"
" GH repo".format(gh_user))
gh_remote_name = 'github-{}'.format(gh_user)
subp(['git', 'remote', 'add', gh_remote_name, gh_remote])
try:
subp(['git', 'fetch', gh_remote_name])
except:
log("ERROR: [github] Could not fetch remote '{remote}'."
"Please create a fork for your github user by clicking 'Fork'"
" from {gh_upstream}".format(
remote=gh_remote, gh_upstream=GH_UPSTREAM_URL))
sys.exit(1)
return (lp_remote_name, gh_remote_name)
def create_migration_branch(
branch_name, upstream, lp_user, gh_user, commit_msg):
"""Create an LP to Github migration branch and add lp_user->gh_user."""
log("Creating a migration branch: {} adding your users".format(
MIGRATE_BRANCH_NAME))
create_publish_branch(upstream, MIGRATE_BRANCH_NAME)
lp_to_git_map = {}
lp_to_git_file = os.path.join(os.getcwd(), 'tools', LP_TO_GIT_USER_FILE)
if os.path.exists(lp_to_git_file):
with open(lp_to_git_file) as stream:
lp_to_git_map = util.load_json(stream.read())
if gh_user in lp_to_git_map.values():
raise RuntimeError(
"github user '{}' already in {}".format(gh_user, lp_to_git_file))
if lp_user in lp_to_git_map:
raise RuntimeError(
"launchpad user '{}' already in {}".format(
lp_user, lp_to_git_file))
lp_to_git_map[lp_user] = gh_user
with open(lp_to_git_file, 'w') as stream:
stream.write(util.json_dumps(lp_to_git_map))
subp(['git', 'add', lp_to_git_file])
commit_file = os.path.join(os.path.dirname(os.getcwd()), 'commit.msg')
with open(commit_file, 'wb') as stream:
stream.write(commit_msg.encode('utf-8'))
subp(['git', 'commit', '--all', '-F', commit_file])
def main():
global DRYRUN
global VERBOSITY
parser = get_parser()
args = parser.parse_args()
DRYRUN = args.dryrun
VERBOSITY = 1 if args.verbose else 0
repo_dir = args.repo_dir or PUBLISH_DIR
if not os.path.exists(repo_dir):
cleanup_repo_dir = True
subp(['git', 'clone',
LP_UPSTREAM_PATH_TMPL.format(launchpad_user=args.launchpad_user),
repo_dir])
else:
cleanup_repo_dir = False
cwd = os.getcwd()
os.chdir(repo_dir)
log("Syncing master branch with upstream")
subp(['git', 'checkout', 'master'])
subp(['git', 'pull'])
try:
lp_remote_name, gh_remote_name = add_lp_and_github_remotes(
args.launchpad_user, args.github_user)
commit_msg = COMMIT_MSG_TMPL.format(
gh_username=args.github_user, lp_username=args.launchpad_user)
create_migration_branch(
MIGRATE_BRANCH_NAME, args.upstream, args.launchpad_user,
args.github_user, commit_msg)
for push_remote in (lp_remote_name, gh_remote_name):
subp(['git', 'push', push_remote, MIGRATE_BRANCH_NAME, '--force'])
except Exception as e:
error('Failed setting up migration branches: {0}'.format(e))
finally:
os.chdir(cwd)
if cleanup_repo_dir and os.path.exists(repo_dir):
util.del_dir(repo_dir)
# Make merge request on LP
log("[launchpad] Automatically creating merge proposal using launchpadlib")
lp = Launchpad.login_with(
"server-team github-migration tool", 'production', version='devel')
master = lp.git_repositories.getByPath(
path='cloud-init').getRefByPath(path='master')
LP_BRANCH_PATH='~{launchpad_user}/cloud-init/+git/cloud-init'
lp_git_repo = lp.git_repositories.getByPath(
path=LP_BRANCH_PATH.format(launchpad_user=args.launchpad_user))
lp_user_migrate_branch = lp_git_repo.getRefByPath(
path='refs/heads/migrate-lp-to-github')
lp_merge_url = (
'https://code.launchpad.net/' +
LP_BRANCH_PATH.format(launchpad_user=args.launchpad_user) +
'/+ref/' + MIGRATE_BRANCH_NAME)
try:
lp_user_migrate_branch.createMergeProposal(
commit_message=commit_msg, merge_target=master, needs_review=True)
except Exception:
log('[launchpad] active merge proposal already exists at:\n'
'{url}\n'.format(url=lp_merge_url))
else:
log("[launchpad] Merge proposal created at:\n{url}.\n".format(
url=lp_merge_url))
log("To link your account to github open your browser and"
" click 'Create pull request' at the following URL:\n"
"{url}".format(url=GITHUB_PULL_URL.format(
github_user=args.github_user, branch=MIGRATE_BRANCH_NAME)))
if os.path.exists(repo_dir):
util.del_dir(repo_dir)
return 0
if __name__ == '__main__':
sys.exit(main())