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)