def invoke_script(args):
"""Assuming we have a mounted filesystem, invoke the script in the
command library"""
# make a Prereqs object
prereqs = core.Prereqs()
prereqs.fs_shell = args.shell
# if we're looking up the snippets library
# we should see 'snippets' in the keys
if 'snippets' in args.keys and 'packages' in args.keys:
# get the package info that corresponds to the package name
# or get the default
last = args.keys.pop()
info_list = look_up_lib(args.keys)
info_dict = command_lib.check_for_unique_package(
info_list, args.package)[last]
else:
info_dict = look_up_lib(args.keys)
result = collect.get_pkg_attrs(info_dict,
prereqs,
package_name=args.package)
print()
print("*************************************************************")
print(" Command Library Script Verification mode ")
print("*************************************************************")
print()
print('Output list: ' + ' '.join(result[0]))
print('Error messages: ' + result[1])
print('Number of elements: ' + str(len(result[0])))
print()
def execute_live(args):
"""Execute inventory at container build time
We assume a mounted working directory is ready to inventory"""
logger.debug('Starting analysis...')
# create the working directory
setup()
# create a layer object to bundle package metadata into
layer = ImageLayer("")
# see if there is an os-release file at the mount point
layer.os_guess = single_layer.find_os_release(args.live)
# create a Prereqs object to store requirements to inventory
prereqs = core.Prereqs()
prereqs.host_path = os.path.abspath(args.live)
# Find a shell that may exist in the layer
prereqs.fs_shell = dcom.find_shell(prereqs.host_path)
# Find the host's shell
prereqs.host_shell = host.check_shell()
# collect metadata into the layer object
fill_packages(layer, prereqs)
# resolve unique packages for this run with reports from previous runs
if args.with_context:
# get a list of previous layers based on plugin type
context_layers = get_context_layers(args.with_context,
args.report_format)
# resolve the packages for each of the layers
context_layers.append(layer)
resolve_context_packages(context_layers)
final_layer = context_layers.pop()
else:
final_layer = layer
# report out the packages
logger.debug("Preparing report")
report.report_layer(final_layer, args)
def analyze_subsequent_layers(image_obj, shell, master_list, options):
"""Assuming that we have a shell and have completed analyzing the first
layer of the given image object, we now analyze the remaining layers.
While we have layers:
1. Check if the layer is empty. If it is, then we can't do anything and
we should continue
2. See if we can load the layer from cache. If we can't then do a
fresh analysis
package information and bundle it into the image object
3. Update the master list"""
curr_layer = 1
# make a Prereqs object
prereqs = core.Prereqs()
prereqs.shell = shell
# get list of environment variables
prereqs.envs = lock.get_env_vars(image_obj)
while curr_layer < len(image_obj.layers):
# make a notice for each layer
origin_next_layer = 'Layer {}'.format(
image_obj.layers[curr_layer].layer_index)
# check if this is an empty layer
if common.is_empty_layer(image_obj.layers[curr_layer]):
# we continue to the next layer
logger.warning(errors.empty_layer)
image_obj.layers[curr_layer].origins.add_notice_to_origins(
origin_next_layer, Notice(errors.empty_layer, 'warning'))
curr_layer = curr_layer + 1
continue
if not common.load_from_cache(image_obj.layers[curr_layer],
options.redo):
fresh_analysis(image_obj, curr_layer, prereqs, options)
# update the master list
dcom.update_master_list(master_list, image_obj.layers[curr_layer])
curr_layer = curr_layer + 1
def analyze_first_layer(image_obj, master_list, options):
"""Analyze the first layer of an image. Return a Prereqs object for the
next layer.
1. Check if the layer is empty. If it is not, return None
2. See if we can load the layer from cache
3. If we can't load from cache
3.1 See if we can find any information about the rootfs
3.2 If we are able to find any information, use any prescribed methods
to extract package information
4. Process and bundle that information into the image object
5. Return a Prereqs object for subsequent layer processing"""
# set up a notice origin for the first layer
origin_first_layer = 'Layer {}'.format(image_obj.layers[0].layer_index)
# check if the layer is empty
if com.is_empty_layer(image_obj.layers[0]):
logger.warning(errors.empty_layer)
image_obj.layers[0].origins.add_notice_to_origins(
origin_first_layer, Notice(errors.empty_layer, 'warning'))
return None
# create a Prereqs object
prereqs = core.Prereqs()
# find the shell from the first layer
prereqs.fs_shell = dcom.get_shell(image_obj.layers[0])
# find a shell for the host
prereqs.host_shell = host.check_shell()
if not prereqs.fs_shell and not prereqs.host_shell:
logger.warning(errors.no_shell)
image_obj.layers[0].origins.add_notice_to_origins(
origin_first_layer, Notice(errors.no_shell, 'warning'))
# find the binary from the first layer
prereqs.binary = dcom.get_base_bin(image_obj.layers[0])
# try to load packages from cache
if not com.load_from_cache(image_obj.layers[0], options.redo):
# add a notice if there is a "created by"
image_obj.layers[0].origins.add_notice_to_origins(
origin_first_layer, Notice(formats.layer_created_by.format(
created_by=image_obj.layers[0].created_by), 'info'))
# set a possible OS and package format
get_os_style(image_obj.layers[0], prereqs.binary)
# if there is a binary, extract packages
if prereqs.binary:
# mount the first layer
target_dir = prep_first_layer(image_obj.layers[0])
# set the host path to the mount point
if target_dir:
prereqs.host_path = target_dir
# core default execution on the first layer
core.execute_base(image_obj.layers[0], prereqs)
else:
logger.warning(errors.no_package_manager)
image_obj.layers[0].origins.add_notice_to_origins(
origin_first_layer, Notice(
errors.no_package_manager, 'warning'))
return None
# populate the master list with all packages found in the first layer
for p in image_obj.layers[0].packages:
master_list.append(p)
return prereqs
def analyze_first_layer(image_obj, master_list, options):
"""Analyze the first layer of an image. Return the installed shell.
If there is no installed shell, return None
1. Check if the layer is empty. If it is then we can't find a shell
2. See if we can load the layer from cache
3. If we can't load from cache
3.1 See if we can find any information about the rootfs
3.2 If we are able to find any information, use any prescribed methods
to extract package information
4. Process and bundle that information into the image object
5. Return the shell for subsequent layer processing"""
# set up a notice origin for the first layer
origin_first_layer = 'Layer {}'.format(image_obj.layers[0].layer_index)
# check if the layer is empty
if com.is_empty_layer(image_obj.layers[0]):
logger.warning(errors.empty_layer)
image_obj.layers[0].origins.add_notice_to_origins(
origin_first_layer, Notice(errors.empty_layer, 'warning'))
return None
# create a Prereqs object
prereqs = core.Prereqs()
# find the shell from the first layer
prereqs.shell = dcom.get_shell(image_obj.layers[0])
if not prereqs.shell:
logger.warning(errors.no_shell)
image_obj.layers[0].origins.add_notice_to_origins(
origin_first_layer, Notice(errors.no_shell, 'warning'))
# find the binary from the first layer
prereqs.binary = dcom.get_base_bin(image_obj.layers[0])
if not prereqs.binary:
logger.warning(errors.no_package_manager)
image_obj.layers[0].origins.add_notice_to_origins(
origin_first_layer, Notice(errors.no_package_manager, 'warning'))
# try to load packages from cache
if not com.load_from_cache(image_obj.layers[0], options.redo):
# set a possible OS
get_os_style(image_obj.layers[0], prereqs.binary)
# if there is a binary, extract packages
if prereqs.shell and prereqs.binary:
# mount the first layer
mount_first_layer(image_obj.layers[0])
# core default execution on the first layer
core.execute_base(image_obj.layers[0], prereqs)
# unmount
rootfs.undo_mount()
rootfs.unmount_rootfs()
# populate the master list with all packages found in the first layer
for p in image_obj.layers[0].packages:
master_list.append(p)
return prereqs.shell
def execute_live(args):
"""Execute inventory at container build time
We assume a mounted working directory is ready to inventory"""
logger.debug('Starting analysis...')
# create the working directory
setup()
# create a layer object to bundle package metadata into
layer = ImageLayer("")
# see if there is an os-release file at the mount point
layer.os_guess = single_layer.find_os_release(args.live)
# create a Prereqs object to store requirements to inventory
prereqs = core.Prereqs()
prereqs.host_path = os.path.abspath(args.live)
# Find a shell that may exist in the layer
prereqs.fs_shell = dcom.find_shell(prereqs.host_path)
# Find the host's shell
prereqs.host_shell = host.check_shell()
# collect metadata into the layer object
fill_packages(layer, prereqs)
# report out the packages
report.report_layer(layer, args)