def setup(dockerfile=None, image_tag_string=None):
'''Any initial setup'''
# generate random names for image, container, and tag
general.initialize_names()
# load the cache
cache.load()
# load dockerfile if present
if dockerfile:
dhelper.load_docker_commands(dockerfile)
# check if the docker image is present
if image_tag_string and general.check_tar(image_tag_string) is False:
if container.check_image(image_tag_string) is None:
# if no docker image is present, try to pull it
if container.pull_image(image_tag_string) is None:
logger.fatal("%s", errors.cannot_find_image.format(
imagetag=image_tag_string))
sys.exit()
def execute_dockerfile(args): # noqa C901,R0912
'''Execution path if given a dockerfile'''
dfile = ''
dfile_lock = False
if args.name == 'report':
dfile = args.dockerfile
else:
dfile = args.lock
dfile_lock = True
logger.debug("Parsing Dockerfile...")
dfobj = dockerfile.get_dockerfile_obj(dfile)
# expand potential ARG values so base image tag is correct
dockerfile.expand_arg(dfobj)
dockerfile.expand_vars(dfobj)
# Store dockerfile path and commands so we can access it during execution
dhelper.load_docker_commands(dfobj)
# attempt to build the image
logger.debug('Building Docker image...')
image_info = docker_api.build_and_dump(dfile)
if image_info:
# attempt to load the built image metadata
full_image = report.load_full_image(dfile, '')
if full_image.origins.is_empty():
# image loading was successful
# Add an image origin here
full_image.origins.add_notice_origin(
formats.dockerfile_image.format(dockerfile=dfile))
# analyze image
analyze(full_image, args, dfile_lock, dfobj)
completed = True
else:
# we cannot analyze the full image, but maybe we can
# analyze the base image
logger.warning('Cannot retrieve full image metadata')
# clean up image tarballs
if not args.keep_wd:
prep.clean_image_tars(full_image)
else:
# cannot build the image
logger.warning('Cannot build image')
# check if we have analyzed the full image or not
if not completed:
# Try to analyze the base image
logger.debug('Analyzing base image...')
base_image = report.load_base_image()
if base_image.origins.is_empty():
# image loading was successful
# add a notice stating failure to build image
base_image.origins.add_notice_to_origins(
dfile, Notice(
formats.image_build_failure, 'warning'))
# analyze image
analyze(base_image, args, dfile_lock, dfobj)
else:
# we cannot load the base image
logger.warning('Cannot retrieve base image metadata')
stub_image = get_dockerfile_packages()
if args.name == 'report':
if not args.keep_wd:
report.clean_image_tars(base_image)
# generate report based on what images were created
if not dfile_lock:
if completed:
report.report_out(args, full_image)
else:
report.report_out(args, base_image, stub_image)
else:
logger.debug('Parsing Dockerfile to generate report...')
output = dockerfile.create_locked_dockerfile(dfobj)
dockerfile.write_locked_dockerfile(output, args.output_file)
# cleanup
if not args.keep_wd:
prep.clean_image_tars(full_image)