def test_clone_origin(self):
git = self.git
# Make the origin we're going to test the clone against
# This is intentionally different from upstream so that
# we can confirm that upstream is also setup properly.
origin_user = '******'
origin_basedir = os.path.join(self.base_temp_dir, origin_user)
os.makedirs(origin_basedir)
check_subprocess('git -C "{origin_dir}" clone "{upstream}"'.format(
origin_dir=origin_basedir, upstream=self.git_dir))
test_parent = os.path.join(self.base_temp_dir, 'test_clone_origin')
os.makedirs(test_parent)
test_dir = os.path.join(test_parent, TEST_REPO_NAME)
origin_dir = os.path.join(origin_basedir, TEST_REPO_NAME)
self.git.clone_repository_to_path(origin_dir,
test_dir,
upstream_url=self.git_dir)
want_tags = git.query_tag_commits(self.git_dir, TAG_VERSION_PATTERN)
have_tags = git.query_tag_commits(test_dir, TAG_VERSION_PATTERN)
self.assertEquals(want_tags, have_tags)
got = check_subprocess('git -C "{dir}" remote -v'.format(dir=test_dir))
remote = git.ORIGIN_REMOTE_NAME
decoy = os.path.join(git.options.scratch_dir, 'nebula_decoys',
os.path.basename(self.git_dir))
# Upstream repo is configured for pulls, but not for pushes.
self.assertEquals(
'\n'.join([
'{remote}\t{origin} (fetch)'.format(remote=remote,
origin=origin_dir),
'{remote}\t{origin} (push)'.format(remote=remote,
origin=origin_dir),
'origin\t{decoy} (fetch)'.format(decoy=decoy),
'origin\t{decoy} (push)'.format(decoy=decoy),
'upstream\t{upstream} (fetch)'.format(upstream=self.git_dir),
'upstream\tdisabled (push)'
]), got)
reference = git.determine_remote_git_repository(test_dir)
self.assertEquals(
RemoteGitRepository.make_from_url(
origin_dir,
upstream_ref=RemoteGitRepository.make_from_url(self.git_dir)),
reference)
def test_clone_upstream(self):
git = self.git
test_parent = os.path.join(self.base_temp_dir, 'test_clone_upstream')
os.makedirs(test_parent)
test_dir = os.path.join(test_parent, TEST_REPO_NAME)
git.clone_repository_to_path(self.git_dir, test_dir)
self.assertTrue(os.path.exists(os.path.join(test_dir, 'base_file')))
want_tags = git.query_tag_commits(self.git_dir, TAG_VERSION_PATTERN)
have_tags = git.query_tag_commits(test_dir, TAG_VERSION_PATTERN)
self.assertEquals(want_tags, have_tags)
got = check_subprocess('git -C "{dir}" remote -v'.format(dir=test_dir))
# Disable pushes to the origni
# No upstream since origin is upstream
remote = git.ORIGIN_REMOTE_NAME
decoy = os.path.join(git.options.scratch_dir, 'nebula_decoys',
os.path.basename(self.git_dir))
self.assertEquals(
'\n'.join([
'{remote}\t{origin} (fetch)'.format(remote=remote,
origin=self.git_dir),
'{remote}\tdisabled (push)'.format(remote=remote),
'origin\t{decoy} (fetch)'.format(decoy=decoy),
'origin\t{decoy} (push)'.format(decoy=decoy)
]), got)
reference = git.determine_remote_git_repository(test_dir)
self.assertEquals(RemoteGitRepository.make_from_url(self.git_dir),
reference)
def setUpClass(cls):
cls.git = GitRunner(make_default_options())
cls.base_temp_dir = tempfile.mkdtemp(prefix='scm_test')
origin_root = os.path.join(cls.base_temp_dir, 'origin_repos')
repository_list = [
RemoteGitRepository.make_from_url(url) for url in [
os.path.join(origin_root, SCM_USER, 'RepoOne'),
os.path.join(origin_root, SCM_USER, 'RepoTwo'),
os.path.join(origin_root, TEST_USER, 'RepoTest')
]
]
cls.TEST_SOURCE_REPOSITORIES = {
repo.name: repo
for repo in repository_list
}
for repo in repository_list:
os.makedirs(repo.url)
base_file = os.path.join(repo.url,
'{name}-base.txt'.format(name=repo.name))
unique_file = os.path.join(
repo.url, '{name}-unique.txt'.format(name=repo.name))
untagged_file = os.path.join(
repo.url, '{name}-untagged.txt'.format(name=repo.name))
logging.debug('Initializing repository %s', repo.url)
git_prefix = 'git -C "{dir}" '.format(dir=repo.url)
run_git = lambda cmd: git_prefix + cmd
check_subprocess_sequence([
# BASE_VERSION
'touch "{file}"'.format(file=base_file),
run_git(' init'),
run_git(
'add "{file}"'.format(file=os.path.basename(base_file))),
run_git('commit -a -m "feat(first): first commit"'),
run_git('tag {base_version} HEAD'.format(
base_version=BASE_VERSION)),
# Add Unique branch name per repo
run_git('checkout -b {name}-branch'.format(name=repo.name)),
'touch "{file}"'.format(file=unique_file),
run_git(
'add "{file}"'.format(file=os.path.basename(unique_file))),
run_git('commit -a -m "chore(uniq): unique commit"'),
# Add a common branch name, but without a tag on HEAD
run_git('checkout master'),
run_git('checkout -b {branch}'.format(branch=UNTAGGED_BRANCH)),
'touch "{file}"'.format(file=untagged_file),
run_git('add "{file}"'.format(
file=os.path.basename(untagged_file))),
run_git('commit -a -m "chore(uniq): untagged commit"'),
run_git('checkout master')
])
def _do_determine_source_repositories(self):
"""Implements RepositoryCommand interface."""
options = self.options
all_source_repos = dict(SPINNAKER_BOM_REPOSITORIES)
all_source_repos.update(SPINNAKER_HALYARD_REPOSITORIES)
if options.github_user in ('upstream', 'default'):
source_repositories = all_source_repos
else:
github = 'https://github.com/{user}'.format(user=options.github_user)
source_repositories = {
name: RemoteGitRepository(name, '%s/%s' % (github, name), upstream)
for name, upstream in all_source_repos.items()
}
return self.filter_repositories(source_repositories)
import re
from buildtool.command import (RepositoryCommandFactory,
RepositoryCommandProcessor)
from buildtool.git import (RemoteGitRepository, GitRunner)
from buildtool.source_code_manager import (SPINNAKER_RUNNABLE_REPOSITORIES)
from buildtool.util import (determine_logfile_path,
check_subprocesses_to_logfile)
# See BuildGceComponentImages class comment as to why these are "repositories"
ALL_IMAGE_REPOSITORIES = dict(SPINNAKER_RUNNABLE_REPOSITORIES)
ALL_IMAGE_REPOSITORIES.update({
name: RemoteGitRepository.make_from_url('https://placeholder/' + name)
for name in ['consul', 'redis', 'vault']
})
class BuildGceComponentImages(RepositoryCommandProcessor):
"""Builds GCE VM images for each of the runtime components.
Although we are calling this a RepositoryCommandProcessor, it
isnt really processing repositories. Some of the images we generate
are not associated with github or repos at all (e.g. redis). However
the RepositoryCommandProcessor is a useful abstraction for its ability
to parallelize across the different subsystems so we're going to overload
it and pretend we have repositories even though we'll never do anything
with their urls.
def _new_google_git_repo(name):
return RemoteGitRepository.make_from_url('https://github.com/google/%s' %
name)
def __new_spinnaker_git_repo(name):
return RemoteGitRepository.make_from_url(
'https://github.com/spinnaker/%s' % name)
