def __init__(self, dockyard_address, image_name, image_tag, dockyard_alias):
self._dockyard_dict = {}
if not dockyard_address:
self._dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
dockyard_address = self._dockyard_dict['address']
self.dockyard_alias = dockyard_alias
super(RemoteArmadaImage, self).__init__(dockyard_address, image_name, image_tag)
def command_push(args):
image_name = args.microservice_name
if not image_name:
raise ArmadaCommandException('ERROR: Please specify microservice_name argument'
' or set MICROSERVICE_NAME environment variable')
dockyard_alias = args.dockyard
image = ArmadaImage(image_name, dockyard_alias)
if '/' not in image_name:
if not ArmadaImage(image.microservice_name, 'local').exists():
raise Exception('Image {image.microservice_name} does not exist. Typo?'.format(**locals()))
dockyard_string = image.dockyard_address or ''
dockyard_string += ' (alias: {dockyard_alias})'.format(**locals()) if dockyard_alias else ''
print('Pushing microservice {image.microservice_name} to dockyard: {dockyard_string}...'.format(
**locals()))
tag_command = 'docker tag -f {image.microservice_name} {image.image_path}'.format(**locals())
assert execute_local_command(tag_command, stream_output=True, retries=1)[0] == 0
else:
# If command was called with [docker_registry_address]/[microservice_name] and no -d/--dockyard, then simply
# mimic 'docker push' behavior (without tagging).
print('Pushing image {image}...'.format(**locals()))
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
did_print = print_dockyard_unavailability_warning(dockyard_dict.get("address"),
dockyard_dict.get("user"),
dockyard_dict.get("password"),
"ERROR! Cannot push to dockyard!")
retries = 0 if did_print else 3
login_to_dockyard(dockyard_alias)
push_command = 'docker push {image.image_path}'.format(**locals())
assert execute_local_command(push_command, stream_output=True, retries=retries)[0] == 0
def command_push(args):
if not args.image_path:
raise ArmadaCommandException('ERROR: Please specify image_path argument'
' or set MICROSERVICE_NAME environment variable')
dockyard_alias = args.dockyard
image = ArmadaImage(args.image_path, dockyard_alias)
if '/' not in args.image_path:
if not ArmadaImage(image.image_name, 'local').exists():
raise Exception('Image {} does not exist. Typo?'.format(image.image_name))
dockyard_string = image.dockyard.url or ''
dockyard_string += ' (alias: {})'.format(dockyard_alias) if dockyard_alias else ''
print('Pushing image {} to dockyard: {}...'.format(image.image_name, dockyard_string))
tag_command = 'docker tag -f {} {}'.format(image.image_name, image.image_path)
assert execute_local_command(tag_command, stream_output=True, retries=1)[0] == 0
else:
# If command was called with [docker_registry_address]/[image_name] and no -d/--dockyard, then simply
# mimic 'docker push' behavior (without tagging).
print('Pushing image {}...'.format(image))
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
did_print = False
d = dockyard_factory(dockyard_dict.get('address'), dockyard_dict.get('user'), dockyard_dict.get('password'))
if d.is_http():
did_print = print_http_dockyard_unavailability_warning(
dockyard_dict['address'],
dockyard_alias,
"ERROR! Cannot push to dockyard!",
)
retries = 0 if did_print else 3
login_to_dockyard(dockyard_alias)
push_command = 'docker push {}'.format(image.image_path)
assert execute_local_command(push_command, stream_output=True, retries=retries)[0] == 0
def __init__(self, microservice_name_or_image_path, dockyard_alias=None):
self.dockyard_address, self.microservice_name = ArmadaImage.__split_image_path(microservice_name_or_image_path)
self.dockyard_alias = dockyard_alias
self.dockyard_dict = None
self.dockyard_auth = None
self.dockyard_url = None
if self.dockyard_address:
if dockyard_alias:
raise ArmadaCommandException('Ambiguous dockyard. Please specify either -d/--dockyard '
'or dockyard_ip[:port]/microservice_name')
self.image_path = microservice_name_or_image_path
elif dockyard_alias == 'local':
self.image_path = microservice_name_or_image_path
else:
self.dockyard_dict = dockyard.get_dockyard_dict(self.dockyard_alias)
self.dockyard_address = self.dockyard_dict['address']
self.image_path = self.dockyard_address + '/' + self.microservice_name
if self.dockyard_address:
if self.dockyard_dict and 'user' in self.dockyard_dict and 'password' in self.dockyard_dict:
self.dockyard_auth = (self.dockyard_dict['user'], self.dockyard_dict['password'])
if '://' in self.dockyard_address:
self.dockyard_url = self.dockyard_address
else:
if self.dockyard_auth or is_dockyard_address_accessible("https://" + self.dockyard_address):
protocol = 'https'
else:
protocol = 'http'
self.dockyard_url = protocol + '://' + self.dockyard_address
def command_build(args):
if args.squash:
chain_run_commands()
base_image_name = _get_base_image_name()
dockyard_alias = args.dockyard or dockyard.get_dockyard_alias(base_image_name, is_run_locally=True)
try:
image = ArmadaImageFactory(args.microservice_name, dockyard_alias, os.environ.get('MICROSERVICE_NAME'))
except InvalidImagePathException:
raise ValueError('No microservice name supplied.')
if not os.path.exists('Dockerfile'):
print('ERROR: Dockerfile not found in current directory', file=sys.stderr)
return
base_image = ArmadaImageFactory(base_image_name, dockyard_alias)
if base_image.is_remote():
if not base_image.exists():
if dockyard_alias == DOCKYARD_FALLBACK_ALIAS:
was_fallback_dockyard = True
else:
print('Base image {base_image} not found. Searching in official Armada dockyard...'.format(**locals()))
dockyard_alias = DOCKYARD_FALLBACK_ALIAS
base_image = ArmadaImageFactory(base_image_name, dockyard_alias)
was_fallback_dockyard = False
if was_fallback_dockyard or not base_image.exists():
print('Base image {base_image} not found. Aborting.'.format(**locals()))
sys.exit(1)
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
did_print = False
d = dockyard_factory(dockyard_dict.get('address'), dockyard_dict.get('user'), dockyard_dict.get('password'))
if d.is_http():
did_print = print_http_dockyard_unavailability_warning(
dockyard_dict['address'],
dockyard_alias,
"ERROR! Cannot pull from dockyard!",
)
retries = 0 if did_print else 3
base_image_path = base_image.image_path
if is_verbose():
print('Fetching base image: "{base_image_path}".\n'.format(**locals()))
pull_command = 'docker pull {base_image_path}'.format(**locals())
assert execute_local_command(pull_command, stream_output=True, retries=retries)[0] == 0
if base_image_path != base_image_name:
if is_verbose():
print('Tagging "{base_image_path}" as "{base_image_name}"\n'.format(**locals()))
tag_command = docker_backend.build_tag_command(base_image_path, base_image_name)
assert execute_local_command(tag_command, stream_output=True, retries=1)[0] == 0
build_command = 'docker build -t {} .'.format(image.image_name_with_tag)
assert execute_local_command(build_command, stream_output=True)[0] == 0
if args.squash:
os.rename('Dockerfile.tmp', 'Dockerfile')
squash_command = 'docker-squash {} -t {}'.format(image.image_name_with_tag,
image.image_name_with_tag)
assert execute_local_command(squash_command, stream_output=True)[0] == 0
def command_build(args):
microservice_name = args.microservice_name or os.environ.get(
'MICROSERVICE_NAME')
if not microservice_name:
raise ValueError('No microservice name supplied.')
if not os.path.exists('Dockerfile'):
print('ERROR: Dockerfile not found in current directory',
file=sys.stderr)
return
base_image_name = _get_base_image_name()
dockyard_alias = args.dockyard or dockyard.get_dockyard_alias(
base_image_name, is_run_locally=True)
base_image = ArmadaImage(base_image_name, dockyard_alias)
if base_image.is_remote():
if not base_image.exists():
if dockyard_alias == DOCKYARD_FALLBACK_ALIAS:
was_fallback_dockyard = True
else:
print(
'Base image {base_image} not found. Searching in official Armada dockyard...'
.format(**locals()))
dockyard_alias = DOCKYARD_FALLBACK_ALIAS
base_image = ArmadaImage(base_image_name, dockyard_alias)
was_fallback_dockyard = False
if was_fallback_dockyard or not base_image.exists():
print('Base image {base_image} not found. Aborting.'.format(
**locals()))
sys.exit(1)
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
did_print = False
d = dockyard_factory(dockyard_dict.get('address'),
dockyard_dict.get('user'),
dockyard_dict.get('password'))
if d.is_http():
did_print = print_http_dockyard_unavailability_warning(
dockyard_dict['address'],
dockyard_alias,
"ERROR! Cannot pull from dockyard!",
)
retries = 0 if did_print else 3
base_image_path = base_image.image_path
pull_command = 'docker pull {base_image_path}'.format(**locals())
assert execute_local_command(pull_command,
stream_output=True,
retries=retries)[0] == 0
if base_image_path != base_image_name:
tag_command = 'docker tag -f {base_image_path} {base_image_name}'.format(
**locals())
assert execute_local_command(tag_command,
stream_output=True,
retries=1)[0] == 0
build_command = 'docker build -t {microservice_name} .'.format(**locals())
assert execute_local_command(build_command, stream_output=True)[0] == 0
def dockyard(self):
if self._dockyard is None:
dockyard_address = self.dockyard_address
if not dockyard_address:
self._dockyard_dict = dockyard.get_dockyard_dict(self.dockyard_alias)
dockyard_address = self._dockyard_dict['address']
self._dockyard = dockyard.remote_dockyard_factory(dockyard_address,
self._dockyard_dict.get('user'),
self._dockyard_dict.get('password'))
return self._dockyard
def command_push(args):
try:
source_image = ArmadaImageFactory(args.image_path, 'local',
os.environ.get('MICROSERVICE_NAME'))
except InvalidImagePathException:
raise ArmadaCommandException(
'ERROR: Please specify image_path argument'
' or set MICROSERVICE_NAME environment variable')
notify_about_detected_dev_environment(source_image.image_name)
dockyard_alias = args.dockyard
if not source_image.dockyard_address:
if not source_image.exists():
raise Exception('Image {} does not exist. Typo?'.format(
source_image.image_name_with_tag))
destination_image = ArmadaImageFactory(
source_image.image_name_with_tag, dockyard_alias)
dockyard_string = destination_image.dockyard.url or ''
dockyard_string += ' (alias: {})'.format(
dockyard_alias) if dockyard_alias else ''
print('Pushing image {} to dockyard: {}...'.format(
source_image.image_name_with_tag, dockyard_string))
tag_command = "docker tag {} {}".format(
source_image.image_name_with_tag,
destination_image.image_path_with_tag)
print(tag_command)
assert execute_local_command(tag_command,
stream_output=True,
retries=1)[0] == 0
else:
# If command was called with [docker_registry_address]/[image_name] and no -d/--dockyard, then simply
# mimic 'docker push' behavior (without tagging).
print('Pushing image {}...'.format(source_image.image_path_with_tag))
destination_image = source_image
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
did_print = False
d = dockyard_factory(dockyard_dict.get('address'),
dockyard_dict.get('user'),
dockyard_dict.get('password'))
if d.is_http():
did_print = print_http_dockyard_unavailability_warning(
dockyard_dict['address'],
dockyard_alias,
"ERROR! Cannot push to dockyard!",
)
retries = 0 if did_print else 3
login_to_dockyard(dockyard_alias)
push_command = 'docker push {}'.format(
destination_image.image_path_with_tag)
assert execute_local_command(push_command,
stream_output=True,
retries=retries)[0] == 0
def __init__(self, dockyard_address, image_name, image_tag, dockyard_alias):
self.image_name, self.image_tag = image_name, image_tag
dockyard_dict = {}
if not dockyard_address:
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
dockyard_address = dockyard_dict['address']
self.image_path = '{}/{}'.format(dockyard_address, self.image_name)
self.dockyard = dockyard.remote_dockyard_factory(dockyard_address,
dockyard_dict.get('user'),
dockyard_dict.get('password'))
def __init__(self, dockyard_address, image_name, image_tag,
dockyard_alias):
self.image_name, self.image_tag = image_name, image_tag
dockyard_dict = {}
if not dockyard_address:
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
dockyard_address = dockyard_dict['address']
self.image_path = '{}/{}'.format(dockyard_address, self.image_name)
self.dockyard = dockyard.remote_dockyard_factory(
dockyard_address, dockyard_dict.get('user'),
dockyard_dict.get('password'))
def login_to_dockyard(dockyard_alias):
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
if not dockyard_dict:
raise ArmadaCommandException("Couldn't read configuration for dockyard alias {0}.".format(dockyard_alias))
dockyard_user = dockyard_dict.get('user')
dockyard_password = dockyard_dict.get('password')
if dockyard_user and dockyard_password:
dockyard_address = dockyard_dict.get('address')
current_user_email = '{0}@{1}'.format(pwd.getpwuid(os.getuid()).pw_name, socket.gethostname())
login_command = 'docker login --username="******" --password="******" --email="{current_user_email}" {dockyard_address}'.format(**locals())
if execute_local_command(login_command)[0] != 0:
raise ArmadaCommandException('ERROR: Could not login to dockyard with alias {dockyard_alias}.'.format(**locals()))
def login_to_dockyard(dockyard_alias):
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
if not dockyard_dict:
raise ArmadaCommandException("Couldn't read configuration for dockyard alias {0}.".format(dockyard_alias))
dockyard_user = dockyard_dict.get('user')
dockyard_password = dockyard_dict.get('password')
if dockyard_user and dockyard_password:
dockyard_address = dockyard_dict.get('address')
login_command = ('docker login --username="******" --password="******" '
'{dockyard_address}').format(**locals())
if execute_local_command(login_command)[0] != 0:
raise ArmadaCommandException(
'ERROR: Could not login to dockyard with alias {dockyard_alias}.'.format(**locals()))
def _pull_base_image(base_image, source_base_image_path, dockyard_alias):
if base_image.is_remote():
did_print = False
if not base_image.dockyard_address:
if not base_image.exists():
if dockyard_alias == DOCKYARD_FALLBACK_ALIAS:
was_fallback_dockyard = True
else:
print('Base image {base_image} not found. '
'Searching in official Armada dockyard...'.format(
**locals()))
dockyard_alias = DOCKYARD_FALLBACK_ALIAS
base_image = ArmadaImageFactory(source_base_image_path,
dockyard_alias)
was_fallback_dockyard = False
if was_fallback_dockyard or not base_image.exists():
raise ArmadaCommandException(
'Base image {base_image} not found. Aborting.'.format(
**locals()))
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
d = dockyard_factory(dockyard_dict.get('address'),
dockyard_dict.get('user'),
dockyard_dict.get('password'))
if d.is_http():
did_print = print_http_dockyard_unavailability_warning(
dockyard_dict['address'],
dockyard_alias,
"ERROR! Cannot pull from dockyard!",
)
retries = 0 if did_print else 3
base_image_path = base_image.image_path_with_tag
if is_verbose():
print('Fetching base image: "{base_image_path}".\n'.format(
**locals()))
pull_command = 'docker pull {base_image_path}'.format(**locals())
assert execute_local_command(pull_command,
stream_output=True,
retries=retries)[0] == 0
else:
base_image = ArmadaImageFactory(base_image.image_name, 'local')
if not base_image.exists():
raise ArmadaCommandException(
'Base image {base_image} not found. Aborting.'.format(
**locals()))
base_image_path = base_image.image_path_with_tag
return base_image_path
def login_to_dockyard(dockyard_alias):
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
if not dockyard_dict:
raise ArmadaCommandException("Couldn't read configuration for dockyard alias {0}.".format(dockyard_alias))
dockyard_user = dockyard_dict.get('user')
dockyard_password = dockyard_dict.get('password')
if dockyard_user and dockyard_password:
dockyard_address = dockyard_dict.get('address')
current_user_email = '{0}@{1}'.format(pwd.getpwuid(os.getuid()).pw_name, socket.gethostname())
login_command = ('docker login --username="******" --password="******" '
'--email="{current_user_email}" {dockyard_address}').format(**locals())
if execute_local_command(login_command)[0] != 0:
raise ArmadaCommandException(
'ERROR: Could not login to dockyard with alias {dockyard_alias}.'.format(**locals()))
def command_build(args):
microservice_name = args.microservice_name or os.environ.get('MICROSERVICE_NAME')
if not microservice_name:
raise ValueError('No microservice name supplied.')
if not os.path.exists('Dockerfile'):
print('ERROR: Dockerfile not found in current directory', file=sys.stderr)
return
base_image_name = _get_base_image_name()
dockyard_alias = args.dockyard or dockyard.get_dockyard_alias(base_image_name, is_run_locally=True)
base_image = ArmadaImage(base_image_name, dockyard_alias)
if base_image.is_remote():
if not base_image.exists():
if dockyard_alias == DOCKYARD_FALLBACK_ALIAS:
was_fallback_dockyard = True
else:
print('Base image {base_image} not found. Searching in official Armada dockyard...'.format(**locals()))
dockyard_alias = DOCKYARD_FALLBACK_ALIAS
base_image = ArmadaImage(base_image_name, dockyard_alias)
was_fallback_dockyard = False
if was_fallback_dockyard or not base_image.exists():
print('Base image {base_image} not found. Aborting.'.format(**locals()))
sys.exit(1)
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
did_print = False
d = dockyard_factory(dockyard_dict.get('address'), dockyard_dict.get('user'), dockyard_dict.get('password'))
if d.is_http():
did_print = print_http_dockyard_unavailability_warning(
dockyard_dict['address'],
dockyard_alias,
"ERROR! Cannot pull from dockyard!",
)
retries = 0 if did_print else 3
base_image_path = base_image.image_path
pull_command = 'docker pull {base_image_path}'.format(**locals())
assert execute_local_command(pull_command, stream_output=True, retries=retries)[0] == 0
if base_image_path != base_image_name:
tag_command = 'docker tag -f {base_image_path} {base_image_name}'.format(**locals())
assert execute_local_command(tag_command, stream_output=True, retries=1)[0] == 0
build_command = 'docker build -t {microservice_name} .'.format(**locals())
assert execute_local_command(build_command, stream_output=True)[0] == 0
def __init__(self, image_path, dockyard_alias=None):
self.dockyard = None
dockyard_address, self.image_name = ArmadaImage.__split_image_path(image_path)
dockyard_dict = {}
if dockyard_address:
if dockyard_alias:
raise ArmadaCommandException('Ambiguous dockyard. Please specify either -d/--dockyard '
'or dockyard_hostname[:port]/image_name')
elif dockyard_alias == 'local':
pass
else:
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
dockyard_address = dockyard_dict['address']
image_path = dockyard_address + '/' + self.image_name
self.image_path = image_path
self.dockyard = dockyard_factory(dockyard_address,
dockyard_dict.get('user'),
dockyard_dict.get('password'))
def __init__(self, image_path, dockyard_alias=None):
self.dockyard = None
dockyard_address, self.image_name = ArmadaImage.__split_image_path(
image_path)
dockyard_dict = {}
if dockyard_address:
if dockyard_alias:
raise ArmadaCommandException(
'Ambiguous dockyard. Please specify either -d/--dockyard '
'or dockyard_hostname[:port]/image_name')
elif dockyard_alias == 'local':
pass
else:
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
dockyard_address = dockyard_dict['address']
image_path = dockyard_address + '/' + self.image_name
self.image_path = image_path
self.dockyard = dockyard_factory(dockyard_address,
dockyard_dict.get('user'),
dockyard_dict.get('password'))
def command_push(args):
try:
source_image = ArmadaImageFactory(args.image_path, "local", os.environ.get("MICROSERVICE_NAME"))
except InvalidImagePathException:
raise ArmadaCommandException(
"ERROR: Please specify image_path argument" " or set MICROSERVICE_NAME environment variable"
)
dockyard_alias = args.dockyard
if not source_image.dockyard_address:
if not source_image.exists():
raise Exception("Image {} does not exist. Typo?".format(source_image.image_name_with_tag))
destination_image = ArmadaImageFactory(source_image.image_name_with_tag, dockyard_alias)
dockyard_string = destination_image.dockyard.url or ""
dockyard_string += " (alias: {})".format(dockyard_alias) if dockyard_alias else ""
print("Pushing image {} to dockyard: {}...".format(source_image.image_name_with_tag, dockyard_string))
tag_command = docker_backend.build_tag_command(
source_image.image_name_with_tag, destination_image.image_path_with_tag
)
print(tag_command)
assert execute_local_command(tag_command, stream_output=True, retries=1)[0] == 0
else:
# If command was called with [docker_registry_address]/[image_name] and no -d/--dockyard, then simply
# mimic 'docker push' behavior (without tagging).
print("Pushing image {}...".format(source_image.image_path_with_tag))
destination_image = source_image
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
did_print = False
d = dockyard_factory(dockyard_dict.get("address"), dockyard_dict.get("user"), dockyard_dict.get("password"))
if d.is_http():
did_print = print_http_dockyard_unavailability_warning(
dockyard_dict["address"], dockyard_alias, "ERROR! Cannot push to dockyard!"
)
retries = 0 if did_print else 3
login_to_dockyard(dockyard_alias)
push_command = "docker push {}".format(destination_image.image_path_with_tag)
assert execute_local_command(push_command, stream_output=True, retries=retries)[0] == 0
def command_build(args):
dockerfile_path = args.file
if not os.path.exists(dockerfile_path):
raise ArmadaCommandException(
'ERROR: {} not found.'.format(dockerfile_path))
base_image_name = _get_base_image_name(dockerfile_path)
dockyard_alias = args.dockyard or dockyard.get_dockyard_alias(
base_image_name, is_run_locally=True)
try:
image = ArmadaImageFactory(args.microservice_name, dockyard_alias,
os.environ.get('MICROSERVICE_NAME'))
except InvalidImagePathException:
raise ArmadaCommandException('No microservice name supplied.')
notify_about_detected_dev_environment(image.image_name)
base_image = ArmadaImageFactory(base_image_name, dockyard_alias)
if base_image.is_remote():
if not base_image.exists():
if dockyard_alias == DOCKYARD_FALLBACK_ALIAS:
was_fallback_dockyard = True
else:
print(
'Base image {base_image} not found. Searching in official Armada dockyard...'
.format(**locals()))
dockyard_alias = DOCKYARD_FALLBACK_ALIAS
base_image = ArmadaImageFactory(base_image_name,
dockyard_alias)
was_fallback_dockyard = False
if was_fallback_dockyard or not base_image.exists():
raise ArmadaCommandException(
'Base image {base_image} not found. Aborting.'.format(
**locals()))
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
did_print = False
d = dockyard_factory(dockyard_dict.get('address'),
dockyard_dict.get('user'),
dockyard_dict.get('password'))
if d.is_http():
did_print = print_http_dockyard_unavailability_warning(
dockyard_dict['address'],
dockyard_alias,
"ERROR! Cannot pull from dockyard!",
)
retries = 0 if did_print else 3
base_image_path = base_image.image_path_with_tag
if is_verbose():
print('Fetching base image: "{base_image_path}".\n'.format(
**locals()))
pull_command = 'docker pull {base_image_path}'.format(**locals())
assert execute_local_command(pull_command,
stream_output=True,
retries=retries)[0] == 0
if base_image_path != base_image_name:
if is_verbose():
print('Tagging "{base_image_path}" as "{base_image_name}"\n'.
format(**locals()))
tag_command = "docker tag {} {}".format(base_image_path,
base_image_name)
assert execute_local_command(tag_command,
stream_output=True,
retries=1)[0] == 0
build_command = 'docker build {} -f {} -t {} .'.format(
'--squash' if args.squash else '', dockerfile_path,
image.image_name_with_tag)
assert execute_local_command(build_command, stream_output=True)[0] == 0
def command_build(args):
dockerfile_path = args.file
if args.squash:
if dockerfile_path != 'Dockerfile':
raise ArmadaCommandException(
'You cannot use --file flag together with -s/--squash.')
chain_run_commands()
if not os.path.exists(dockerfile_path):
print('ERROR: {} not found.'.format(dockerfile_path), file=sys.stderr)
return
base_image_name = _get_base_image_name(dockerfile_path)
dockyard_alias = args.dockyard or dockyard.get_dockyard_alias(
base_image_name, is_run_locally=True)
try:
image = ArmadaImageFactory(args.microservice_name, dockyard_alias,
os.environ.get('MICROSERVICE_NAME'))
except InvalidImagePathException:
raise ValueError('No microservice name supplied.')
base_image = ArmadaImageFactory(base_image_name, dockyard_alias)
if base_image.is_remote():
if not base_image.exists():
if dockyard_alias == DOCKYARD_FALLBACK_ALIAS:
was_fallback_dockyard = True
else:
print(
'Base image {base_image} not found. Searching in official Armada dockyard...'
.format(**locals()))
dockyard_alias = DOCKYARD_FALLBACK_ALIAS
base_image = ArmadaImageFactory(base_image_name,
dockyard_alias)
was_fallback_dockyard = False
if was_fallback_dockyard or not base_image.exists():
print('Base image {base_image} not found. Aborting.'.format(
**locals()))
sys.exit(1)
dockyard_dict = dockyard.get_dockyard_dict(dockyard_alias)
did_print = False
d = dockyard_factory(dockyard_dict.get('address'),
dockyard_dict.get('user'),
dockyard_dict.get('password'))
if d.is_http():
did_print = print_http_dockyard_unavailability_warning(
dockyard_dict['address'],
dockyard_alias,
"ERROR! Cannot pull from dockyard!",
)
retries = 0 if did_print else 3
base_image_path = base_image.image_path_with_tag
if is_verbose():
print('Fetching base image: "{base_image_path}".\n'.format(
**locals()))
pull_command = 'docker pull {base_image_path}'.format(**locals())
assert execute_local_command(pull_command,
stream_output=True,
retries=retries)[0] == 0
if base_image_path != base_image_name:
if is_verbose():
print('Tagging "{base_image_path}" as "{base_image_name}"\n'.
format(**locals()))
tag_command = docker_backend.build_tag_command(
base_image_path, base_image_name)
assert execute_local_command(tag_command,
stream_output=True,
retries=1)[0] == 0
build_command = 'docker build -f {} -t {} .'.format(
dockerfile_path, image.image_name_with_tag)
assert execute_local_command(build_command, stream_output=True)[0] == 0
if args.squash:
os.rename('Dockerfile.tmp', 'Dockerfile')
squash_command = 'docker-squash {} -t {}'.format(
image.image_name_with_tag, image.image_name_with_tag)
assert execute_local_command(squash_command,
stream_output=True)[0] == 0
