def BuildDocker(buildSelection):
VersionTools.ExportVersionFromChangelogToEnvironment('CHANGELOG.md', 'VERSION')
composeFiles = [
'docker-compose.yml'
]
if buildSelection == "run":
DockerComposeTools.DockerComposeUp(composeFiles)
if buildSelection == "run":
DockerComposeTools.DockerComposeUp(composeFiles)
elif buildSelection == "test":
testContainerNames = ['my-service']
DockerComposeTools.ExecuteComposeTests(composeFiles, testContainerNames)
elif buildSelection == "publish":
BuildDocker("build")
DockerComposeTools.DockerComposePush(composeFiles)
DockerComposeTools.PublishDockerImagesWithNewTag(composeFiles, 'latest')
elif buildSelection == "help":
TerminalTools.PrintAvailableCommands(AvailableCommands)
else:
print("Please provide a valid build argument: ")
BuildDocker("help")
def MergeAndPopulateWithContainerNames(composeFiles, testComposeFile):
DockerComposeTools.MergeComposeFiles(composeFiles, testComposeFile)
yamlData = YamlTools.GetYamlData([testComposeFile])
DockerComposeTools.AddContainerNames(yamlData)
YamlTools.DumpYamlDataToFile(yamlData, testComposeFile)
containerNames = DockerComposeTools.GetContainerNames(yamlData)
return containerNames
def PublishContainerSelection(publishSelection, selectionToPublish):
composeFiles = publishSelection[BuildTools.FILES_KEY]
publishComposeFile = BuildTools.GetAvailableComposeFilename(
'publish', selectionToPublish)
DockerComposeTools.MergeComposeFiles(composeFiles, publishComposeFile)
try:
DockerComposeTools.PublishDockerImages(publishComposeFile)
except:
BuildTools.RemoveComposeFileIfNotPreserved(publishComposeFile,
publishSelection)
raise
if BuildTools.ADDITIONAL_TAG_KEY in publishSelection:
DockerComposeTools.PublishDockerImagesWithNewTag(
publishComposeFile,
publishSelection[BuildTools.ADDITIONAL_TAG_KEY])
if BuildTools.ADDITIONAL_TAGS_KEY in publishSelection:
for tag in publishSelection[BuildTools.ADDITIONAL_TAGS_KEY]:
DockerComposeTools.PublishDockerImagesWithNewTag(
publishComposeFile, tag)
if BuildTools.COMPOSE_FILE_WITH_DIGESTS_KEY in publishSelection:
composeFileWithDigests = publishSelection[
BuildTools.COMPOSE_FILE_WITH_DIGESTS_KEY]
BuildTools.GenerateComposeFileWithDigests(composeFiles,
composeFileWithDigests)
BuildTools.RemoveComposeFileIfNotPreserved(publishComposeFile,
publishSelection)
def PublishContainerSelection(publishSelection, publishSelectionKey):
composeFiles = publishSelection[BuildTools.FILES_KEY]
publishComposeFile = 'docker-compose.publish.' + publishSelectionKey + '.yml'
DockerComposeTools.MergeComposeFiles(composeFiles, publishComposeFile)
DockerComposeTools.PublishDockerImages(publishComposeFile)
if BuildTools.ADDITIONAL_TAG_KEY in publishSelection:
DockerComposeTools.PublishDockerImagesWithNewTag(publishComposeFile, publishSelection[BuildTools.ADDITIONAL_TAG_KEY])
def BuildSelection(buildSelection, selectionToBuild):
cwd = BuildTools.TryChangeToDirectoryAndGetCwd(buildSelection)
oldEnvironmentVariable = BuildTools.AddEnvironmentVariablesFromSelection(buildSelection)
BuildTools.HandleTerminalCommandsSelection(buildSelection)
TerminalTools.LoadDefaultEnvironmentVariablesFile()
if BuildTools.FILES_KEY in buildSelection:
composeFiles = buildSelection[BuildTools.FILES_KEY]
buildComposeFile = BuildTools.GetAvailableComposeFilename('build', selectionToBuild)
DockerComposeTools.MergeComposeFiles(composeFiles, buildComposeFile)
try:
DockerComposeTools.DockerComposeBuild([buildComposeFile])
except:
BuildTools.RemoveComposeFileIfNotPreserved(buildComposeFile, buildSelection)
raise
if BuildTools.ADDITIONAL_TAG_KEY in buildSelection:
DockerComposeTools.TagImages(buildComposeFile, buildSelection[BuildTools.ADDITIONAL_TAG_KEY])
if BuildTools.ADDITIONAL_TAGS_KEY in buildSelection:
for tag in buildSelection[BuildTools.ADDITIONAL_TAGS_KEY]:
DockerComposeTools.TagImages(buildComposeFile, tag)
if SAVE_IMAGES_KEY in buildSelection:
outputFolder = buildSelection[SAVE_IMAGES_KEY]
DockerComposeTools.SaveImages(buildComposeFile, outputFolder)
if BuildTools.COMPOSE_FILE_WITH_DIGESTS_KEY in buildSelection:
composeFileWithDigests = buildSelection[BuildTools.COMPOSE_FILE_WITH_DIGESTS_KEY]
BuildTools.GenerateComposeFileWithDigests(composeFiles, composeFileWithDigests)
BuildTools.RemoveComposeFileIfNotPreserved(buildComposeFile, buildSelection)
BuildTools.RemoveEnvironmentVariables(oldEnvironmentVariable)
os.chdir(cwd)
def ExecuteStackAsProcess(stackFile: str,
stacksFolder: str,
noLogs: bool,
logsFolder: str,
artifactIdentifier='docker-compose.'):
stackName, version, stackFileIsValid = StackVersionTools.GetStackNameAndVersionFromStackFile(
stackFile, artifactIdentifier=artifactIdentifier)
if not (stackFileIsValid):
exitCode = 0
return exitCode
temporaryStackFile = __GenerateStackFileWithContainerNames(
stackFile, stackName, version, stacksFolder)
try:
DockerComposeTools.DockerComposeUp([temporaryStackFile])
exitCode = __VerifyStackExecutedSuccessfully(temporaryStackFile,
stackName, version,
noLogs, logsFolder)
DockerComposeTools.DockerComposeDown([temporaryStackFile])
finally:
os.remove(temporaryStackFile)
if exitCode > 0:
warnings.warn("Stack '" + stackName + "' FAILED!")
else:
print(stackName + " stack finished with success.")
return exitCode
def PromoteImageSelection(promoteSelection, selectionToPromote):
print("selection to promote: {}".format(selectionToPromote))
composeFiles = promoteSelection[BuildTools.FILES_KEY]
promoteComposeFile = BuildTools.GetAvailableComposeFilename(
'promote', selectionToPromote)
DockerComposeTools.MergeComposeFiles(composeFiles, promoteComposeFile)
sourceFeed = YamlTools.TryGetFromDictionary(promoteSelection,
BuildTools.SOURCE_FEED_KEY,
None)
targetFeed = YamlTools.TryGetFromDictionary(promoteSelection,
BuildTools.TARGET_FEED_KEY,
None)
user = YamlTools.TryGetFromDictionary(promoteSelection,
BuildTools.USER_KEY, None)
password = YamlTools.TryGetFromDictionary(promoteSelection,
BuildTools.PASSWORD_KEY, None)
logout = YamlTools.TryGetFromDictionary(promoteSelection,
BuildTools.LOGOUT_KEY, False)
dryRun = YamlTools.TryGetFromDictionary(promoteSelection,
BuildTools.DRY_RUN_KEY, False)
DockerComposeTools.PromoteDockerImages(
composeFile=promoteComposeFile,
targetTags=promoteSelection[BuildTools.TARGET_TAGS_KEY],
sourceFeed=sourceFeed,
targetFeed=targetFeed,
user=user,
password=password,
logoutFromFeeds=logout,
dryRun=dryRun)
BuildTools.RemoveComposeFileIfNotPreserved(promoteComposeFile,
promoteSelection)
def BuildSelection(buildSelection, selectionToBuild):
cwd = BuildTools.TryChangeToDirectoryAndGetCwd(buildSelection)
composeFiles = buildSelection[BuildTools.FILES_KEY]
buildComposeFile = 'docker-compose.build.' + selectionToBuild + '.yml'
DockerComposeTools.MergeComposeFiles(composeFiles, buildComposeFile)
DockerComposeTools.DockerComposeBuild([buildComposeFile])
if BuildTools.ADDITIONAL_TAG_KEY in buildSelection:
DockerComposeTools.TagImages(buildComposeFile, buildSelection[BuildTools.ADDITIONAL_TAG_KEY])
os.chdir(cwd)
def RunSelection(runSelection, selectionToRun):
cwd = BuildTools.TryChangeToDirectoryAndGetCwd(runSelection)
oldEnvironmentVariable = BuildTools.AddEnvironmentVariablesFromSelection(
runSelection)
BuildTools.HandleTerminalCommandsSelection(runSelection)
TerminalTools.LoadDefaultEnvironmentVariablesFile()
if BuildTools.FILES_KEY in runSelection:
runComposeFile = BuildTools.GetAvailableComposeFilename(
'run', selectionToRun)
composeFiles = runSelection[BuildTools.FILES_KEY]
if YamlTools.TryGetFromDictionary(runSelection,
VERIFY_CONTAINER_EXIT_CODE, False):
containerNames = BuildTools.MergeAndPopulateWithContainerNames(
composeFiles, runComposeFile)
if BuildTools.CONTAINER_NAMES_KEY in runSelection:
containerNames = runSelection[BuildTools.CONTAINER_NAMES_KEY]
else:
containerNames = []
DockerComposeTools.MergeComposeFiles(composeFiles, runComposeFile)
try:
DockerComposeTools.DockerComposeUp(
[runComposeFile],
YamlTools.TryGetFromDictionary(runSelection,
ABORT_ON_CONTAINER_EXIT_KEY,
True),
YamlTools.TryGetFromDictionary(runSelection, DETACHED_KEY,
False))
except:
BuildTools.RemoveComposeFileIfNotPreserved(runComposeFile,
runSelection)
raise
DockerImageTools.VerifyContainerExitCode(containerNames,
assertExitCodes=True)
BuildTools.HandleCopyFromContainer(runSelection)
if YamlTools.TryGetFromDictionary(runSelection,
BuildTools.REMOVE_CONTAINERS_KEY,
False):
DockerComposeTools.DockerComposeRemove([runComposeFile])
BuildTools.RemoveComposeFileIfNotPreserved(runComposeFile,
runSelection)
BuildTools.RemoveEnvironmentVariables(oldEnvironmentVariable)
os.chdir(cwd)
def test_RunStacks(self):
cacheFolder = 'tests/cacheFolder'
shutil.rmtree(cacheFolder, ignore_errors=True)
DockerComposeTools.DockerComposeBuild(
["tests/testBatchStacks/docker-compose.batch.1.0.0.yml"])
defaultArgs = [
'--cache', cacheFolder, '--source', 'tests/testBatchStacks',
'--user', 'dummy:password', '-i',
'tests/testBatchStacks/swarm.management.yml'
]
self.assertTrue(os.path.isdir('tests/testBatchStacks'))
args = ['init'] + defaultArgs
Main.Main(args)
TestUtilities.AssertInfrastructureExists(True)
os.environ['SHOULD_FAIL'] = 'false'
os.environ['SHOULD_FAIL_2'] = 'false'
args = ['run', 'batch'] + defaultArgs
Main.Main(args)
os.environ['SHOULD_FAIL'] = 'true'
os.environ['SHOULD_FAIL_2'] = 'false'
args = ['run', 'batch'] + defaultArgs
self.assertRaises(Exception, Main.Main, args)
def TestSelection(testSelection):
cwd = BuildTools.TryChangeToDirectoryAndGetCwd(testSelection)
BuildTools.HandleTerminalCommandsSelection(testSelection)
if BuildTools.FILES_KEY in testSelection:
DockerComposeTools.ExecuteComposeTests(
testSelection[BuildTools.FILES_KEY],
testSelection[CONTAINER_NAMES_KEY], False)
BuildTools.HandleCopyFromContainer(testSelection)
if BuildTools.TryGetFromDictionary(testSelection, REMOVE_CONTAINERS_KEY, False):
DockerComposeTools.DockerComposeRemove(
testSelection[BuildTools.FILES_KEY])
os.chdir(cwd)
def test_c_ComposeRemove(self):
print('COMPOSE REMOVE')
TerminalTools.LoadEnvironmentVariables(
os.path.join(TestTools.TEST_SAMPLE_FOLDER, '.env'))
DockerComposeTools.DockerComposeRemove(
[os.path.join(TestTools.TEST_SAMPLE_FOLDER, 'docker-compose.yml')])
print('DONE COMPOSE REMOVE')
def RunSelection(runSelection):
cwd = BuildTools.TryChangeToDirectoryAndGetCwd(runSelection)
DockerComposeTools.DockerComposeUp(
runSelection[BuildTools.FILES_KEY],
BuildTools.TryGetFromDictionary(runSelection,
ABORT_ON_CONTAINER_EXIT_KEY, True),
BuildTools.TryGetFromDictionary(runSelection, DETACHED_KEY, False))
os.chdir(cwd)
def test_d_TagImages(self):
print('COMPOSE TAG')
TerminalTools.LoadEnvironmentVariables(
os.path.join(TestTools.TEST_SAMPLE_FOLDER, '.env'))
DockerComposeTools.TagImages(
os.path.join(TestTools.TEST_SAMPLE_FOLDER, 'docker-compose.yml'),
'1.0.0')
print('DONE COMPOSE TAG')
def test_f_ComposeTest(self):
print('COMPOSE TEST')
TerminalTools.LoadEnvironmentVariables(
os.path.join(TestTools.TEST_SAMPLE_FOLDER, '.env'))
DockerComposeTools.ExecuteComposeTests(
[os.path.join(TestTools.TEST_SAMPLE_FOLDER, 'docker-compose.yml')],
['my-service'])
print('DONE COMPOSE TEST')
def TestSelection(testSelection):
cwd = BuildTools.TryChangeToDirectoryAndGetCwd(testSelection)
DockerComposeTools.ExecuteComposeTests(
testSelection[BuildTools.FILES_KEY],
testSelection[CONTAINER_NAMES_KEY],
BuildTools.TryGetFromDictionary(testSelection, REMOVE_CONTAINERS_KEY,
True))
os.chdir(cwd)
def test_g_ComposeTestWithContainerNamesNotSet(self):
print('COMPOSE TEST UNKNOWN NAME')
TerminalTools.LoadEnvironmentVariables(
os.path.join(TestTools.TEST_SAMPLE_FOLDER, '.env'))
yamlData = YamlTools.GetYamlData([
os.path.join(TestTools.TEST_SAMPLE_FOLDER,
'docker-compose.test.yml')
])
DockerComposeTools.AddContainerNames(yamlData)
YamlTools.DumpYamlDataToFile(
yamlData,
os.path.join(TestTools.TEST_SAMPLE_FOLDER,
'docker-compose.test.temp.yml'))
DockerComposeTools.ExecuteComposeTests([
os.path.join(TestTools.TEST_SAMPLE_FOLDER,
'docker-compose.test.temp.yml')
])
print('DONE COMPOSE TEST UNKNOWN NAME')
def BuildDocker(buildSelection):
srcFolder = ['src', '..']
miniSwarmManagementFile = 'swarm-management.yml'
migratorComposeFiles = [
'docker-compose.migrator.yml'
]
generalComposeFiles = [
'docker-compose.yml'
]
if buildSelection == 'run':
os.chdir(srcFolder[0])
DockerComposeTools.DockerComposeUp(migratorComposeFiles)
DockerComposeTools.DockerComposeUp(generalComposeFiles)
os.chdir(srcFolder[1])
elif buildSelection == 'build':
os.chdir(srcFolder[0])
DockerComposeTools.DockerComposeBuild(generalComposeFiles + migratorComposeFiles)
os.chdir(srcFolder[1])
elif buildSelection == 'test':
os.chdir(srcFolder[0])
DockerComposeTools.ExecuteComposeTests(
['docker-compose.tests.yml'], ['kafkaoncontainers-tests'])
os.chdir(srcFolder[1])
elif buildSelection == 'start-dev':
os.chdir(srcFolder[0] + '/ServiceDependencies')
SwarmManager.HandleManagement(['-start', '-f', miniSwarmManagementFile])
os.chdir(srcFolder[1] + '/..')
elif buildSelection == 'stop-dev':
os.chdir(srcFolder[0] + '/ServiceDependencies')
SwarmManager.HandleManagement(['-stop', '-f', miniSwarmManagementFile])
os.chdir(srcFolder[1] + '/..')
elif buildSelection == 'help':
TerminalTools.PrintAvailableCommands(AvailableCommands)
else:
print('Please provide a valid build argument: ')
BuildDocker('help')
def test_f_CreateRemoveStack(self):
print('CREATE STACK')
stack = 'test-stack-' + str(random.randint(0, 10000))
TerminalTools.LoadEnvironmentVariables(
os.path.join(TestTools.TEST_SAMPLE_FOLDER, '.env'))
DockerComposeTools.DockerComposeBuild(
[os.path.join(TestTools.TEST_SAMPLE_FOLDER, 'docker-compose.yml')])
DockerSwarmTools.DeployStack(
os.path.join(TestTools.TEST_SAMPLE_FOLDER, 'docker-compose.yml'),
stack)
DockerSwarmTools.RemoveStack(stack)
print('DONE CREATE STACK')
def test_e_SaveImages(self):
print('COMPOSE SAVE')
folder = os.path.join(TestTools.TEST_SAMPLE_FOLDER, 'output')
print(folder)
TerminalTools.LoadEnvironmentVariables(
os.path.join(TestTools.TEST_SAMPLE_FOLDER, '.env'))
DockerComposeTools.SaveImages(
os.path.join(TestTools.TEST_SAMPLE_FOLDER, 'docker-compose.yml'),
folder)
self.assertTrue(
os.path.isfile(os.path.join(folder, 'my.service-1.0.0.tar')))
print('DONE COMPOSE SAVE')
def BuildSelection(buildSelection, selectionToBuild):
cwd = BuildTools.TryChangeToDirectoryAndGetCwd(buildSelection)
BuildTools.HandleTerminalCommandsSelection(buildSelection)
if BuildTools.FILES_KEY in buildSelection:
composeFiles = buildSelection[BuildTools.FILES_KEY]
buildComposeFile = 'docker-compose.build.' + selectionToBuild + '.yml'
DockerComposeTools.MergeComposeFiles(composeFiles, buildComposeFile)
DockerComposeTools.DockerComposeBuild([buildComposeFile])
if BuildTools.ADDITIONAL_TAG_KEY in buildSelection:
DockerComposeTools.TagImages(
buildComposeFile,
buildSelection[BuildTools.ADDITIONAL_TAG_KEY])
if BuildTools.ADDITIONAL_TAGS_KEY in buildSelection:
for tag in buildSelection[BuildTools.ADDITIONAL_TAGS_KEY]:
DockerComposeTools.TagImages(buildComposeFile, tag)
if SAVE_IMAGES_KEY in buildSelection:
outputFolder = buildSelection[SAVE_IMAGES_KEY]
DockerComposeTools.SaveImages(buildComposeFile, outputFolder)
os.chdir(cwd)
def TestSelection(testSelection, selectionToTest):
cwd = BuildTools.TryChangeToDirectoryAndGetCwd(testSelection)
oldEnvironmentVariable = BuildTools.AddEnvironmentVariablesFromSelection(
testSelection)
BuildTools.HandleTerminalCommandsSelection(testSelection)
TerminalTools.LoadDefaultEnvironmentVariablesFile()
if BuildTools.FILES_KEY in testSelection:
testComposeFile = BuildTools.GetAvailableComposeFilename(
'test', selectionToTest)
composeFiles = testSelection[BuildTools.FILES_KEY]
containerNames = BuildTools.MergeAndPopulateWithContainerNames(
composeFiles, testComposeFile)
if BuildTools.CONTAINER_NAMES_KEY in testSelection:
containerNames = testSelection[BuildTools.CONTAINER_NAMES_KEY]
try:
DockerComposeTools.ExecuteComposeTests(
[testComposeFile],
testContainerNames=containerNames,
removeTestContainers=False,
buildCompose=True,
downCompose=False)
except:
BuildTools.RemoveComposeFileIfNotPreserved(testComposeFile,
testSelection)
raise
BuildTools.HandleCopyFromContainer(testSelection)
DockerComposeTools.DockerComposeDown([testComposeFile])
if YamlTools.TryGetFromDictionary(testSelection,
BuildTools.REMOVE_CONTAINERS_KEY,
False):
DockerComposeTools.DockerComposeRemove([testComposeFile])
BuildTools.RemoveComposeFileIfNotPreserved(testComposeFile,
testSelection)
BuildTools.RemoveEnvironmentVariables(oldEnvironmentVariable)
os.chdir(cwd)
def RunSelection(runSelection):
cwd = BuildTools.TryChangeToDirectoryAndGetCwd(runSelection)
BuildTools.HandleTerminalCommandsSelection(runSelection)
if BuildTools.FILES_KEY in runSelection:
DockerComposeTools.DockerComposeUp(
runSelection[BuildTools.FILES_KEY],
BuildTools.TryGetFromDictionary(runSelection,
ABORT_ON_CONTAINER_EXIT_KEY, True),
BuildTools.TryGetFromDictionary(runSelection, DETACHED_KEY, False))
BuildTools.HandleCopyFromContainer(runSelection)
os.chdir(cwd)
def test_Run(self):
DockerComposeTools.DockerComposeBuild(
["tests/testBatchStacks/docker-compose.batch.1.0.0.yml"])
handler: StackHandler = TestUtilities.CreateStackHandler(
source="tests/testBatchStacks",
swmInfrastructureFiles=[
"tests/testBatchStacks/swarm.management,yml"
])
handler.Init()
os.environ['SHOULD_FAIL'] = 'false'
self.assertTrue(handler.Run())
os.environ['SHOULD_FAIL'] = 'true'
self.assertFalse(handler.Run(['batch==1.0.0']))
def BuildDocker(buildSelection):
VersionTools.ExportVersionFromChangelogToEnvironment(
'CHANGELOG.md', 'VERSION')
srcFolder = ['src', '..']
miniSwarmManagementFile = 'swarm-management.yml'
migratorComposeFiles = ['docker-compose.migrator.yml']
nugetDockerComposeFiles = ['docker-compose.publish.nuget.yml']
generalComposeFiles = [
'docker-compose.message.handler.yml',
'docker-compose.outboxcleaner.yml',
'docker-compose.message.spammer.yml'
]
if buildSelection == 'run':
os.chdir(srcFolder[0])
DockerComposeTools.DockerComposeUp(migratorComposeFiles)
DockerComposeTools.DockerComposeUp(generalComposeFiles)
os.chdir(srcFolder[1])
elif buildSelection == 'build':
os.chdir(srcFolder[0])
DockerComposeTools.DockerComposeBuild(generalComposeFiles +
migratorComposeFiles)
os.chdir(srcFolder[1])
elif buildSelection == 'test':
os.chdir(srcFolder[0])
DockerComposeTools.ExecuteComposeTests(['docker-compose.tests.yml'],
['saferebus-tests'])
os.chdir(srcFolder[1])
elif buildSelection == 'publish':
os.chdir(srcFolder[0])
DockerComposeTools.DockerComposeBuild(nugetDockerComposeFiles)
DockerComposeTools.DockerComposeUp(nugetDockerComposeFiles, False)
os.chdir(srcFolder[1])
elif buildSelection == 'start-dev':
os.chdir(srcFolder[0] + '/ServiceDependencies')
SwarmManager.HandleManagement(
['-start', '-f', miniSwarmManagementFile])
os.chdir(srcFolder[1] + '/..')
elif buildSelection == 'stop-dev':
os.chdir(srcFolder[0] + '/ServiceDependencies')
SwarmManager.HandleManagement(['-stop', '-f', miniSwarmManagementFile])
os.chdir(srcFolder[1] + '/..')
elif buildSelection == 'help':
TerminalTools.PrintAvailableCommands(AvailableCommands)
else:
print('Please provide a valid build argument: ')
BuildDocker('help')
def __GenerateStackFileWithContainerNames(stackFile: str, stackName: str,
version: semantic_version.Version,
stacksFolder: str):
yamlData: dict = YamlTools.GetYamlData([stackFile])
random.seed()
randomId = random.randint(0, 1000)
prefix = stackName + "_"
subfix = "_" + str(randomId)
DockerComposeTools.AddContainerNames(yamlData,
prefix=prefix,
subfix=subfix)
temporaryStackFile = os.path.join(
stacksFolder,
"docker-compose-temp.{0}.{1}.{2}.yml".format(stackName, version,
randomId))
YamlTools.DumpYamlDataToFile(yamlData, temporaryStackFile)
return temporaryStackFile
def test_h_AddDigestsToImageTags(self):
print('COMPOSE ADD DIGESTS')
DockerImageTools.PullImage('nginx')
TerminalTools.LoadEnvironmentVariables(
os.path.join(TestTools.TEST_SAMPLE_FOLDER, '.env'))
yamlData = YamlTools.GetYamlData(
[os.path.join(TestTools.TEST_SAMPLE_FOLDER, 'docker-compose.yml')],
replaceEnvironmentVariablesMatches=False)
DockerComposeTools.AddDigestsToImageTags(yamlData)
for service in yamlData['services']:
if 'my.service' in yamlData['services'][service]['image']:
self.assertEqual('my_repo/my.service:1.0.0',
yamlData['services'][service]['image'])
else:
self.assertTrue(
'nginx@sha256:' in yamlData['services'][service]['image'])
self.assertTrue(yamlData['services'][service]['environment']
['SOME_VARIABLE'] == '${SOME_ENV_VARIABLE}')
print('DONE COMPOSE ADD DIGESTS')
def GenerateComposeFileWithDigests(composeFiles, outputComposeFile):
TerminalTools.LoadDefaultEnvironmentVariablesFile()
yamlData = YamlTools.GetYamlData(composeFiles, replaceEnvironmentVariablesMatches=False)
DockerComposeTools.AddDigestsToImageTags(yamlData)
YamlTools.DumpYamlDataToFile(yamlData, outputComposeFile)
def PublishArtifactSelection(publishSelection):
DockerComposeTools.DockerComposeBuild(
publishSelection[BuildTools.FILES_KEY])
DockerComposeTools.DockerComposeUp(publishSelection[BuildTools.FILES_KEY],
False)
