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)
def test_workspace_materialize_directories_result(self):
#TODO(#8336): at some point, this test should require that Workspace only be invoked from a console_role
workspace = Workspace(self.scheduler)
input_files_content = InputFilesContent((
FileContent(path='a.txt', content=b'hello', is_executable=False),
FileContent(path='subdir/b.txt',
content=b'goodbye',
is_executable=False),
))
digest, = self.scheduler.product_request(Digest, [input_files_content])
with temporary_dir() as tmp_dir:
path1 = Path(tmp_dir, 'a.txt')
path2 = Path(tmp_dir, 'subdir', 'b.txt')
self.assertFalse(path1.is_file())
self.assertFalse(path2.is_file())
output = workspace.materialize_directories(
(DirectoryToMaterialize(path=tmp_dir,
directory_digest=digest), ))
self.assertEqual(type(output), MaterializeDirectoriesResult)
materialize_result = output.dependencies[0]
self.assertEqual(type(materialize_result),
MaterializeDirectoryResult)
self.assertEqual(materialize_result.output_paths, (
str(Path(tmp_dir, 'a.txt')),
str(Path(tmp_dir, 'subdir/b.txt')),
))
def test_workspace_materialize_directories_result(self):
#TODO(#8336): at some point, this test should require that Workspace only be invoked from a console_role
workspace = Workspace(self.scheduler)
input_files_content = InputFilesContent((
FileContent(path='a.txt', content=b'hello'),
FileContent(path='subdir/b.txt', content=b'goodbye'),
))
digest = self.request_single_product(Digest, input_files_content)
path1 = Path('a.txt')
path2 = Path('subdir/b.txt')
assert not path1.is_file()
assert not path2.is_file()
output = workspace.materialize_directories(
(DirectoryToMaterialize(digest), ))
assert type(output) == MaterializeDirectoriesResult
materialize_result = output.dependencies[0]
assert type(materialize_result) == MaterializeDirectoryResult
assert materialize_result.output_paths == tuple(
str(Path(self.build_root, p)) for p in [path1, path2])
def workspace_console_rule(console: Console, workspace: Workspace,
msg: MessageToConsoleRule) -> MockWorkspaceGoal:
digest = yield Get(Digest, InputFilesContent, msg.input_files_content)
output = workspace.materialize_directories(
(DirectoryToMaterialize(path=msg.tmp_dir, directory_digest=digest), ))
output_path = output.dependencies[0].output_paths[0]
console.print_stdout(str(Path(msg.tmp_dir, output_path)), end='')
yield MockWorkspaceGoal(exit_code=0)
def create_binary(addresses: BuildFileAddresses, console: Console,
workspace: Workspace, options: Binary.Options) -> Binary:
with Binary.line_oriented(options, console) as print_stdout:
print_stdout("Generating binaries in `dist/`")
binaries = yield [
Get(CreatedBinary, Address, address.to_address())
for address in addresses
]
dirs_to_materialize = tuple(
DirectoryToMaterialize(path='dist/',
directory_digest=binary.digest)
for binary in binaries)
results = workspace.materialize_directories(dirs_to_materialize)
for result in results.dependencies:
for path in result.output_paths:
print_stdout(f"Wrote {path}")
yield Binary(exit_code=0)
