def get_packages_from_base(base_image_tag):
'''Get a list of package objects from invoking the commands in the
command library base section:
1. For the image and tag name find if there is a list of package names
2. If there is an invoke dictionary, invoke the commands
3. Create a list of packages'''
pkg_list = []
# information under the base image tag in the command library
info = cmds.get_base_info(base_image_tag)
if info:
names = cmds.get_pkg_attr_list(info['shell'], info['names'])
versions = cmds.get_pkg_attr_list(info['shell'], info['versions'])
licenses = cmds.get_pkg_attr_list(info['shell'], info['licenses'])
src_urls = cmds.get_pkg_attr_list(info['shell'], info['src_urls'])
if names and len(names) > 1:
for index in range(0, len(names)):
pkg = Package(names[index])
if len(versions) == len(names):
pkg.version = versions[index]
if len(licenses) == len(names):
pkg.license = licenses[index]
if len(src_urls) == len(names):
pkg.src_url = src_urls[index]
pkg_list.append(pkg)
else:
logger.warning(
cannot_retrieve_base_packages.format(image=base_image_tag[0],
tag=base_image_tag[1]))
else:
logger.warning(
no_image_tag_listing.format(image=base_image_tag[0],
tag=base_image_tag[1]))
return pkg_list
def add_base_packages(image_layer, binary, shell):
'''Given the image layer, the binary to invoke and shell:
1. get the listing from the base.yml
2. Invoke any commands against the base layer
3. Make a list of packages and add them to the layer'''
origin_layer = 'Layer: ' + image_layer.fs_hash[:10]
if image_layer.created_by:
image_layer.origins.add_notice_to_origins(
origin_layer,
Notice(
formats.layer_created_by.format(
created_by=image_layer.created_by), 'info'))
else:
image_layer.origins.add_notice_to_origins(
origin_layer, Notice(formats.no_created_by, 'warning'))
origin_command_lib = formats.invoking_base_commands
# find the binary
listing = command_lib.get_base_listing(binary)
if listing:
# put info notice about what is going to be invoked
snippet_msg = formats.invoke_for_base + '\n' + \
content.print_base_invoke(binary)
image_layer.origins.add_notice_to_origins(origin_layer,
Notice(snippet_msg, 'info'))
shell, msg = command_lib.get_image_shell(listing)
if not shell:
shell = constants.shell
# get all the packages in the base layer
names, n_msg = command_lib.get_pkg_attr_list(shell, listing['names'])
versions, v_msg = command_lib.get_pkg_attr_list(
shell, listing['versions'])
licenses, l_msg = command_lib.get_pkg_attr_list(
shell, listing['licenses'])
src_urls, u_msg = command_lib.get_pkg_attr_list(
shell, listing['src_urls'])
# add a notice to the image if something went wrong
invoke_msg = n_msg + v_msg + l_msg + u_msg
if invoke_msg:
image_layer.origins.add_notice_to_origins(
origin_layer, Notice(invoke_msg, 'error'))
if names and len(names) > 1:
for index in range(0, len(names)):
pkg = Package(names[index])
if len(versions) == len(names):
pkg.version = versions[index]
if len(licenses) == len(names):
pkg.license = licenses[index]
if len(src_urls) == len(names):
pkg.src_url = src_urls[index]
image_layer.add_package(pkg)
# if there is no listing add a notice
else:
image_layer.origins.add_notice_to_origins(
origin_command_lib,
Notice(errors.no_listing_for_base_key.format(listing_key=binary),
'error'))
def testIsEqual(self):
p = Package('x')
p.license = 'TestLicense'
p.version = '1.0'
p.src_url = 'TestUrl'
self.package.license = 'TestLicense'
self.package.version = '2.0'
self.package.src_url = 'TestUrl'
self.assertFalse(self.package.is_equal(p))
p.version = '2.0'
self.assertTrue(self.package.is_equal(p))
def get_package_obj(command_name, package_name, shell):
'''Given the command name, and the package name, retrieve the package
information, create an oject and return the package object'''
# look up command name in snippet library
if command_name in cmds.command_lib['snippets'].keys():
# get the unique or default information
pkg_list = cmds.command_lib['snippets'][command_name]['packages']
pkg_info = check_for_unique_package(pkg_list, package_name)
if pkg_info:
pkg = Package(package_name)
# get the information for values
keys = pkg_info.keys()
if 'version' in keys:
try:
pkg.version = cmds.get_pkg_attr_list(
shell, pkg_info['version'],
package_name=package_name)[0]
except subprocess.CalledProcessError as error:
logger.warning(error.output)
if 'license' in keys:
try:
pkg.license = cmds.get_pkg_attr_list(
shell, pkg_info['license'],
package_name=package_name)[0]
except subprocess.CalledProcessError as error:
logger.warning(error.output)
if 'src_url' in keys:
try:
pkg.src_url = cmds.get_pkg_attr_list(
shell, pkg_info['src_url'],
package_name=package_name)[0]
except subprocess.CalledProcessError as error:
logger.warning(error.output)
return pkg
else:
print(
'No package named {} nor default listing'.format(package_name))
else:
print('No command {} listed in snippet library'.format(command_name))
def add_base_packages(base_layer, binary):
'''Given the base layer and the binary found in layer fs:
1. get the listing from the base.yml
2. Invoke any commands against the base layer
3. Make a list of packages and add them to the layer'''
origin_layer = 'Layer: ' + base_layer.diff_id[:10]
if base_layer.created_by:
base_layer.origins.add_notice_to_origins(origin_layer, Notice(
formats.layer_created_by.format(created_by=base_layer.created_by),
'info'))
else:
base_layer.origins.add_notice_to_origins(origin_layer, Notice(
formats.no_created_by, 'warning'))
origin_command_lib = formats.invoking_base_commands
# find the binary
listing = command_lib.get_base_listing(binary)
if listing:
# put info notice about what is going to be invoked
snippet_msg = formats.invoke_for_base + '\n' + \
content.print_base_invoke(binary)
base_layer.origins.add_notice_to_origins(
origin_layer, Notice(snippet_msg, 'info'))
shell, msg = command_lib.get_image_shell(listing)
if not shell:
# add a warning notice for no shell in the command library
logger.warning('No shell listing in command library. '
'Using default shell')
no_shell_message = errors.no_shell_listing.format(
binary, default_shell=constants.shell)
base_layer.origins.add_notice_to_origins(
origin_command_lib, Notice(no_shell_message, 'warning'))
# add a hint notice to add the shell to the command library
add_shell_message = errors.no_listing_for_base_key.format(
listing_key='shell')
base_layer.origins.add_notice_origins(
origin_command_lib, Notice(add_shell_message, 'hint'))
shell = constants.shell
# get all the packages in the base layer
names, n_msg = command_lib.get_pkg_attr_list(shell, listing['names'])
versions, v_msg = command_lib.get_pkg_attr_list(
shell, listing['versions'])
licenses, l_msg = command_lib.get_pkg_attr_list(
shell, listing['licenses'])
src_urls, u_msg = command_lib.get_pkg_attr_list(
shell, listing['src_urls'])
# add a notice to the image if something went wrong
invoke_msg = n_msg + v_msg + l_msg + u_msg
if invoke_msg:
base_layer.origins.add_notice_to_origins(
origin_layer, Notice(invoke_msg, 'error'))
if names and len(names) > 1:
for index in range(0, len(names)):
pkg = Package(names[index])
if len(versions) == len(names):
pkg.version = versions[index]
if len(licenses) == len(names):
pkg.license = licenses[index]
if len(src_urls) == len(names):
pkg.src_url = src_urls[index]
base_layer.add_package(pkg)
# if there is no listing add a notice
else:
base_layer.origins.add_notice_to_origins(
origin_command_lib, Notice(errors.no_listing_for_base_key.format(
listing_key=binary), 'error'))
def add_base_packages(image):
'''Given an image object, get a list of package objects from
invoking the commands in the command library base section:
1. For the image and tag name find if there is a list of package names
2. If there is an invoke dictionary, invoke the commands
3. Create a list of packages
4. Add them to the image'''
# information under the base image tag in the command library
listing = command_lib.get_base_listing(image.name, image.tag)
# create the origin for the base image
origin_info = formats.invoking_base_commands + '\n' + \
content.print_base_invoke(image.name, image.tag)
image.origins.add_notice_origin(origin_info)
origin_str = 'command_lib/base.yml'
if listing:
shell, msg = command_lib.get_image_shell(listing)
if not shell:
# add a warning notice for no shell in the command library
logger.warning('No shell listing in command library. '
'Using default shell')
no_shell_message = errors.no_shell_listing.format(
image_name=image.name,
image_tag=image.tag,
default_shell=constants.shell)
image.origins.add_notice_to_origins(
origin_str, Notice(no_shell_message, 'warning'))
# add a hint notice to add the shell to the command library
add_shell_message = errors.no_listing_for_base_key.format(
listing_key='shell')
image.origins.add_notice_origins(origin_str,
Notice(add_shell_message, 'hint'))
shell = constants.shell
# check if a container is running first
# eventually this needs to change to use derivatives that have
# more than 1 layer
# for now, we add the list of packages to all the layers in a
# starting base image
if check_container():
names, n_msg = command_lib.get_pkg_attr_list(
shell, listing['names'])
versions, v_msg = command_lib.get_pkg_attr_list(
shell, listing['versions'])
licenses, l_msg = command_lib.get_pkg_attr_list(
shell, listing['licenses'])
src_urls, u_msg = command_lib.get_pkg_attr_list(
shell, listing['src_urls'])
# add a notice to the image if something went wrong
invoke_msg = n_msg + v_msg + l_msg + u_msg
if invoke_msg:
image.origins.add_notice_to_origins(
origin_str, Notice(invoke_msg, 'error'))
if names and len(names) > 1:
for index in range(0, len(names)):
pkg = Package(names[index])
if len(versions) == len(names):
pkg.version = versions[index]
if len(licenses) == len(names):
pkg.license = licenses[index]
if len(src_urls) == len(names):
pkg.src_url = src_urls[index]
for layer in image.layers:
layer.add_package(pkg)
# if no container is running give a logging error
else:
logger.error(errors.no_running_docker_container)
# if there is no listing add a notice
else:
image.origins.add_notice_to_origins(
origin_str,
Notice(
errors.no_image_tag_listing.format(image_name=image.name,
image_tag=image.tag),
'error'))