def Build()

in ftl/python/builder.py [0:0]

• 65 lines of code
• 7 McCabe index (conditional complexity)

    def Build(self):
        lyr_imgs = []
        lyr_imgs.append(self._base_image)

        interpreter_builder = package_builder.InterpreterLayerBuilder(
            virtualenv_dir=self._virtualenv_dir,
            python_cmd=self._python_cmd,
            virtualenv_cmd=self._virtualenv_cmd,
            venv_cmd=self._venv_cmd,
            cache_key_version=self._args.cache_key_version,
            cache=self._cache)
        interpreter_builder.BuildLayer()
        lyr_imgs.append(interpreter_builder.GetImage())

        if ftl_util.has_pkg_descriptor(self._descriptor_files, self._ctx):
            # build interpreter layer

            if self._is_phase2:
                # do a phase 2 build of the package layers w/ Pipfile.lock
                # iterate over package/version Pipfile.lock
                python_util.setup_virtualenv(self._virtualenv_dir,
                                             self._virtualenv_cmd,
                                             self._python_cmd,
                                             self._venv_cmd)
                pkgs = self._parse_pipfile_pkgs()
                with ftl_util.Timing('uploading_all_package_layers'):
                    with concurrent.futures.ThreadPoolExecutor(
                            max_workers=constants.THREADS) as executor:
                        future_to_params = {executor.submit(
                                self._build_pkg, pkg,
                                interpreter_builder, lyr_imgs): pkg
                                for pkg in pkgs
                        }
                        for future in concurrent.futures.as_completed(
                                future_to_params):
                            future.result()
            else:
                # do a phase 1 build of the package layers w/ requirements.txt
                req_txt_builder = package_builder.RequirementsLayerBuilder(
                    ctx=self._ctx,
                    descriptor_files=self._descriptor_files,
                    directory=self._args.directory,
                    pkg_dir=None,
                    wheel_dir=self._wheel_dir,
                    virtualenv_dir=self._virtualenv_dir,
                    python_cmd=self._python_cmd,
                    pip_cmd=self._pip_cmd,
                    virtualenv_cmd=self._virtualenv_cmd,
                    venv_cmd=self._venv_cmd,
                    dep_img_lyr=interpreter_builder,
                    cache_key_version=self._args.cache_key_version,
                    cache=self._cache)
                req_txt_builder.BuildLayer()
                if req_txt_builder.GetImage():
                    lyr_imgs.append(req_txt_builder.GetImage())

        app = base_builder.AppLayerBuilder(
            directory=self._args.directory,
            destination_path=self._args.destination_path,
            entrypoint=self._args.entrypoint,
            exposed_ports=self._args.exposed_ports)
        app.BuildLayer()
        lyr_imgs.append(app.GetImage())
        if self._args.additional_directory:
            additional_directory = base_builder.AppLayerBuilder(
                directory=self._args.additional_directory,
                destination_path=self._args.additional_directory,
                entrypoint=self._args.entrypoint,
                exposed_ports=self._args.exposed_ports)
            additional_directory.BuildLayer()
            lyr_imgs.append(additional_directory.GetImage())
        ftl_image = ftl_util.AppendLayersIntoImage(lyr_imgs)
        self.StoreImage(ftl_image)