def pack_charm_in_instance(self, *, bases_index: int, build_on: Base,
build_on_index: int) -> str:
"""Pack instance in Charm."""
charm_name = format_charm_file_name(self.metadata.name,
self.config.bases[bases_index])
# If building in project directory, use the project path as the working
# directory. The output charms will be placed in the correct directory
# without needing retrieval. If outputing to a directory other than the
# charm project directory, we need to output the charm outside the
# project directory and can retrieve it when complete.
cwd = pathlib.Path.cwd()
if cwd == self.charmdir:
instance_output_dir = get_managed_environment_project_path()
pull_charm = False
else:
instance_output_dir = get_managed_environment_home_path()
pull_charm = True
cmd = ["charmcraft", "pack", "--bases-index", str(bases_index)]
if message_handler.mode == message_handler.VERBOSE:
cmd.append("--verbose")
elif message_handler.mode == message_handler.QUIET:
cmd.append("--quiet")
logger.info(f"Packing charm {charm_name!r}...")
with launched_environment(
charm_name=self.metadata.name,
project_path=self.charmdir,
base=build_on,
bases_index=bases_index,
build_on_index=build_on_index,
) as instance:
try:
instance.execute_run(
cmd,
check=True,
cwd=instance_output_dir.as_posix(),
)
except subprocess.CalledProcessError as error:
capture_logs_from_instance(instance)
raise CommandError(
f"Failed to build charm for bases index '{bases_index}'."
) from error
if pull_charm:
try:
instance.pull_file(
source=instance_output_dir / charm_name,
destination=cwd / charm_name,
)
except FileNotFoundError as error:
raise CommandError(
"Unexpected error retrieving charm from instance."
) from error
return charm_name
def build_charm(self, bases_config: BasesConfiguration) -> str:
"""Build the charm.
:param bases_config: Bases configuration to use for build.
:returns: File name of charm.
:raises CraftError: on lifecycle exception.
:raises RuntimeError: on unexpected lifecycle exception.
"""
if env.is_charmcraft_running_in_managed_mode():
work_dir = env.get_managed_environment_home_path()
else:
work_dir = self.buildpath
emit.progress(f"Building charm in {str(work_dir)!r}")
if self._special_charm_part:
# all current deprecated arguments set charm plugin parameters
self._handle_deprecated_cli_arguments()
# add charm files to the prime filter
self._set_prime_filter()
# set source if empty or not declared in charm part
if not self._special_charm_part.get("source"):
self._special_charm_part["source"] = str(self.charmdir)
# run the parts lifecycle
emit.trace(f"Parts definition: {self._parts}")
lifecycle = parts.PartsLifecycle(
self._parts,
work_dir=work_dir,
project_dir=self.charmdir,
project_name=self.metadata.name,
ignore_local_sources=["*.charm"],
)
lifecycle.run(Step.PRIME)
# run linters and show the results
linting_results = linters.analyze(self.config, lifecycle.prime_dir)
self.show_linting_results(linting_results)
create_manifest(
lifecycle.prime_dir,
self.config.project.started_at,
bases_config,
linting_results,
)
zipname = self.handle_package(lifecycle.prime_dir, bases_config)
emit.message(f"Created '{zipname}'.", intermediate=True)
return zipname
def _pack_bundle(self, parsed_args) -> List[pathlib.Path]:
"""Pack a bundle."""
emit.progress("Packing the bundle.")
if parsed_args.shell:
build.launch_shell()
return []
project = self.config.project
if self.config.parts:
config_parts = self.config.parts.copy()
else:
# "parts" not declared, create an implicit "bundle" part
config_parts = {"bundle": {"plugin": "bundle"}}
# a part named "bundle" using plugin "bundle" is special and has
# predefined values set automatically.
bundle_part = config_parts.get("bundle")
if bundle_part and bundle_part.get("plugin") == "bundle":
special_bundle_part = bundle_part
else:
special_bundle_part = None
# get the config files
bundle_filepath = project.dirpath / "bundle.yaml"
bundle_config = load_yaml(bundle_filepath)
if bundle_config is None:
raise CraftError(
"Missing or invalid main bundle file: {!r}.".format(
str(bundle_filepath)))
bundle_name = bundle_config.get("name")
if not bundle_name:
raise CraftError(
"Invalid bundle config; missing a 'name' field indicating the bundle's name in "
"file {!r}.".format(str(bundle_filepath)))
if special_bundle_part:
# set prime filters
for fname in MANDATORY_FILES:
fpath = project.dirpath / fname
if not fpath.exists():
raise CraftError("Missing mandatory file: {!r}.".format(
str(fpath)))
prime = special_bundle_part.setdefault("prime", [])
prime.extend(MANDATORY_FILES)
# set source if empty or not declared in charm part
if not special_bundle_part.get("source"):
special_bundle_part["source"] = str(project.dirpath)
if env.is_charmcraft_running_in_managed_mode():
work_dir = env.get_managed_environment_home_path()
else:
work_dir = project.dirpath / build.BUILD_DIRNAME
# run the parts lifecycle
emit.trace(f"Parts definition: {config_parts}")
lifecycle = parts.PartsLifecycle(
config_parts,
work_dir=work_dir,
project_dir=project.dirpath,
project_name=bundle_name,
ignore_local_sources=[bundle_name + ".zip"],
)
try:
lifecycle.run(Step.PRIME)
except (RuntimeError, CraftError) as error:
if parsed_args.debug:
emit.trace(f"Error when running PRIME step: {error}")
build.launch_shell()
raise
# pack everything
create_manifest(lifecycle.prime_dir, project.started_at, None, [])
zipname = project.dirpath / (bundle_name + ".zip")
build_zip(zipname, lifecycle.prime_dir)
emit.message(f"Created {str(zipname)!r}.")
if parsed_args.shell_after:
build.launch_shell()
return [zipname]
def test_get_managed_environment_home_path():
dirpath = env.get_managed_environment_home_path()
assert dirpath == pathlib.Path("/root")
def pack_charm_in_instance(self, *, bases_index: int, build_on: Base,
build_on_index: int) -> str:
"""Pack instance in Charm."""
charm_name = format_charm_file_name(self.metadata.name,
self.config.bases[bases_index])
# If building in project directory, use the project path as the working
# directory. The output charms will be placed in the correct directory
# without needing retrieval. If outputing to a directory other than the
# charm project directory, we need to output the charm outside the
# project directory and can retrieve it when complete.
cwd = pathlib.Path.cwd()
if cwd == self.charmdir:
instance_output_dir = env.get_managed_environment_project_path()
pull_charm = False
else:
instance_output_dir = env.get_managed_environment_home_path()
pull_charm = True
cmd = ["charmcraft", "pack", "--bases-index", str(bases_index)]
if emit.get_mode() == EmitterMode.VERBOSE:
cmd.append("--verbose")
elif emit.get_mode() == EmitterMode.QUIET:
cmd.append("--quiet")
elif emit.get_mode() == EmitterMode.TRACE:
cmd.append("--trace")
if self.debug:
cmd.append("--debug")
if self.shell:
cmd.append("--shell")
if self.shell_after:
cmd.append("--shell-after")
emit.progress(f"Launching environment to pack for base {build_on}")
with self.provider.launched_environment(
charm_name=self.metadata.name,
project_path=self.charmdir,
base=build_on,
bases_index=bases_index,
build_on_index=build_on_index,
) as instance:
emit.progress("Packing the charm")
try:
with emit.open_stream(f"Running {cmd}") as stream:
instance.execute_run(
cmd,
check=True,
cwd=instance_output_dir,
stdout=stream,
stderr=stream,
)
except subprocess.CalledProcessError as error:
capture_logs_from_instance(instance)
raise CommandError(
f"Failed to build charm for bases index '{bases_index}'."
) from error
if pull_charm:
try:
instance.pull_file(
source=instance_output_dir / charm_name,
destination=cwd / charm_name,
)
except FileNotFoundError as error:
raise CommandError(
"Unexpected error retrieving charm from instance."
) from error
emit.progress("Charm packed ok")
return charm_name