def run(console: Console, workspace: Workspace, runner: InteractiveRunner,
bfa: BuildFileAddress) -> Run:
target = bfa.to_address()
binary = yield Get(CreatedBinary, Address, target)
with temporary_dir(cleanup=True) as tmpdir:
dirs_to_materialize = (DirectoryToMaterialize(
path=str(tmpdir), directory_digest=binary.digest), )
workspace.materialize_directories(dirs_to_materialize)
console.write_stdout(f"Running target: {target}\n")
full_path = str(Path(tmpdir, binary.binary_name))
run_request = InteractiveProcessRequest(
argv=[full_path],
run_in_workspace=True,
)
try:
result = runner.run_local_interactive_process(run_request)
exit_code = result.process_exit_code
if result.process_exit_code == 0:
console.write_stdout(f"{target} ran successfully.\n")
else:
console.write_stderr(
f"{target} failed with code {result.process_exit_code}!\n")
except Exception as e:
console.write_stderr(
f"Exception when attempting to run {target} : {e}\n")
exit_code = -1
yield Run(exit_code)
async def run(
console: Console,
workspace: Workspace,
runner: InteractiveRunner,
build_root: BuildRoot,
options: RunOptions,
global_options: GlobalOptions,
) -> Run:
targets_to_valid_configs = await Get[TargetsToValidConfigurations](
TargetsToValidConfigurationsRequest(
BinaryConfiguration,
goal_description=f"the `{options.name}` goal",
error_if_no_valid_targets=True,
expect_single_config=True,
))
config = targets_to_valid_configs.configurations[0]
binary = await Get[CreatedBinary](BinaryConfiguration, config)
workdir = global_options.options.pants_workdir
with temporary_dir(root_dir=workdir, cleanup=True) as tmpdir:
path_relative_to_build_root = PurePath(tmpdir).relative_to(
build_root.path).as_posix()
workspace.materialize_directory(
DirectoryToMaterialize(binary.digest,
path_prefix=path_relative_to_build_root))
console.write_stdout(f"Running target: {config.address}\n")
full_path = PurePath(tmpdir, binary.binary_name).as_posix()
run_request = InteractiveProcessRequest(
argv=(full_path, *options.values.args),
run_in_workspace=True,
)
try:
result = runner.run_local_interactive_process(run_request)
exit_code = result.process_exit_code
if result.process_exit_code == 0:
console.write_stdout(f"{config.address} ran successfully.\n")
else:
console.write_stderr(
f"{config.address} failed with code {result.process_exit_code}!\n"
)
except Exception as e:
console.write_stderr(
f"Exception when attempting to run {config.address}: {e!r}\n")
exit_code = -1
return Run(exit_code)
async def run(
console: Console,
workspace: Workspace,
runner: InteractiveRunner,
build_root: BuildRoot,
addresses: Addresses,
options: RunOptions,
) -> Run:
address = addresses.expect_single()
binary = await Get[CreatedBinary](Address, address)
with temporary_dir(root_dir=PurePath(build_root.path,
".pants.d").as_posix(),
cleanup=True) as tmpdir:
path_relative_to_build_root = PurePath(tmpdir).relative_to(
build_root.path).as_posix()
workspace.materialize_directory(
DirectoryToMaterialize(binary.digest,
path_prefix=path_relative_to_build_root))
console.write_stdout(f"Running target: {address}\n")
full_path = PurePath(tmpdir, binary.binary_name).as_posix()
run_request = InteractiveProcessRequest(
argv=(full_path, *options.values.args),
run_in_workspace=True,
)
try:
result = runner.run_local_interactive_process(run_request)
exit_code = result.process_exit_code
if result.process_exit_code == 0:
console.write_stdout(f"{address} ran successfully.\n")
else:
console.write_stderr(
f"{address} failed with code {result.process_exit_code}!\n"
)
except Exception as e:
console.write_stderr(
f"Exception when attempting to run {address}: {e!r}\n")
exit_code = -1
return Run(exit_code)
async def run(
console: Console,
workspace: Workspace,
runner: InteractiveRunner,
build_root: BuildRoot,
bfa: BuildFileAddress,
) -> Run:
target = bfa.to_address()
binary = await Get[CreatedBinary](Address, target)
with temporary_dir(root_dir=str(Path(build_root.path, ".pants.d")),
cleanup=True) as tmpdir:
path_relative_to_build_root = str(
Path(tmpdir).relative_to(build_root.path))
workspace.materialize_directory(
DirectoryToMaterialize(binary.digest,
path_prefix=path_relative_to_build_root))
console.write_stdout(f"Running target: {target}\n")
full_path = str(Path(tmpdir, binary.binary_name))
run_request = InteractiveProcessRequest(
argv=(full_path, ),
run_in_workspace=True,
)
try:
result = runner.run_local_interactive_process(run_request)
exit_code = result.process_exit_code
if result.process_exit_code == 0:
console.write_stdout(f"{target} ran successfully.\n")
else:
console.write_stderr(
f"{target} failed with code {result.process_exit_code}!\n")
except Exception as e:
console.write_stderr(
f"Exception when attempting to run {target} : {e}\n")
exit_code = -1
return Run(exit_code)
async def run(
console: Console,
workspace: Workspace,
runner: InteractiveRunner,
build_root: BuildRoot,
targets_with_origins: TargetsWithOrigins,
options: RunOptions,
global_options: GlobalOptions,
union_membership: UnionMembership,
registered_target_types: RegisteredTargetTypes,
) -> Run:
valid_config_types_by_target = gather_valid_binary_configuration_types(
goal_subsytem=options,
targets_with_origins=targets_with_origins,
union_membership=union_membership,
registered_target_types=registered_target_types,
)
bulleted_list_sep = "\n * "
if len(valid_config_types_by_target) > 1:
binary_target_addresses = sorted(
binary_target.address.spec
for binary_target in valid_config_types_by_target)
raise ValueError(
f"The `run` goal only works on one binary target but was given multiple targets that "
f"can produce a binary:"
f"{bulleted_list_sep}{bulleted_list_sep.join(binary_target_addresses)}\n\n"
f"Please select one of these targets to run.")
target, valid_config_types = list(valid_config_types_by_target.items())[0]
if len(valid_config_types) > 1:
possible_config_types = sorted(config_type.__name__
for config_type in valid_config_types)
# TODO: improve this error message. (It's never actually triggered yet because we only have
# Python implemented with V2.) A better error message would explain to users how they can
# resolve the issue.
raise ValueError(
f"Multiple of the registered binary implementations work for {target.address} "
f"(target type {repr(target.alias)}).\n\n"
f"It is ambiguous which implementation to use. Possible implementations:"
f"{bulleted_list_sep}{bulleted_list_sep.join(possible_config_types)}."
)
config_type = valid_config_types[0]
binary = await Get[CreatedBinary](BinaryConfiguration,
config_type.create(target))
workdir = global_options.options.pants_workdir
with temporary_dir(root_dir=workdir, cleanup=True) as tmpdir:
path_relative_to_build_root = PurePath(tmpdir).relative_to(
build_root.path).as_posix()
workspace.materialize_directory(
DirectoryToMaterialize(binary.digest,
path_prefix=path_relative_to_build_root))
console.write_stdout(f"Running target: {target.address}\n")
full_path = PurePath(tmpdir, binary.binary_name).as_posix()
run_request = InteractiveProcessRequest(
argv=(full_path, *options.values.args),
run_in_workspace=True,
)
try:
result = runner.run_local_interactive_process(run_request)
exit_code = result.process_exit_code
if result.process_exit_code == 0:
console.write_stdout(f"{target.address} ran successfully.\n")
else:
console.write_stderr(
f"{target.address} failed with code {result.process_exit_code}!\n"
)
except Exception as e:
console.write_stderr(
f"Exception when attempting to run {target.address}: {e!r}\n")
exit_code = -1
return Run(exit_code)