def execute(self):
# The called binary may block for a while, allow concurrent pants activity during this pants
# idle period.
#
# TODO(John Sirois): refactor lock so that I can do:
# with self.context.lock.yield():
# - blocking code
#
# Currently re-acquiring the lock requires a path argument that was set up by the goal
# execution engine. I do not want task code to learn the lock location.
# http://jira.local.twitter.com/browse/AWESOME-1317
target = self.require_single_root_target()
working_dir = None
cwd_opt = self.get_options().cwd
if cwd_opt != _CWD_NOT_PRESENT:
working_dir = self.get_options().cwd
if not working_dir:
working_dir = target.address.spec_path
logger.debug("Working dir is {0}".format(working_dir))
if isinstance(target, JvmApp):
binary = target.binary
else:
binary = target
# Some targets will not have extra_jvm_options in their payload,
# so we can't access it with target.payload.extra_jvm_options
extra_jvm_options = target.payload.get_field_value("extra_jvm_options")
# We can't throw if binary isn't a JvmBinary, because perhaps we were called on a
# python_binary, in which case we have to no-op and let python_run do its thing.
# TODO(benjy): Some more elegant way to coordinate how tasks claim targets.
if isinstance(binary, JvmBinary):
jvm = DistributionLocator.cached()
executor = CommandLineGrabber(
jvm) if self.only_write_cmd_line else None
self.context.release_lock()
with self.context.new_workunit(name='run',
labels=[WorkUnitLabel.RUN]):
result = jvm.execute_java(
classpath=self.classpath([target]),
main=self.get_options().main or binary.main,
executor=executor,
jvm_options=self.jvm_options + extra_jvm_options,
args=self.args,
cwd=working_dir,
synthetic_jar_dir=self.workdir,
create_synthetic_jar=self.synthetic_classpath)
if self.only_write_cmd_line:
with safe_open(expand_path(self.only_write_cmd_line),
'w') as outfile:
outfile.write(' '.join(executor.cmd))
elif result != 0:
raise TaskError('java {} ... exited non-zero ({})'.format(
binary.main, result),
exit_code=result)
def execute(self):
# The called binary may block for a while, allow concurrent pants activity during this pants
# idle period.
#
# TODO(John Sirois): refactor lock so that I can do:
# with self.context.lock.yield():
# - blocking code
#
# Currently re-acquiring the lock requires a path argument that was set up by the goal
# execution engine. I do not want task code to learn the lock location.
# http://jira.local.twitter.com/browse/AWESOME-1317
target = self.require_single_root_target()
working_dir = None
cwd_opt = self.get_options().cwd
if cwd_opt != _CWD_NOT_PRESENT:
working_dir = self.get_options().cwd
if not working_dir:
working_dir = target.address.spec_path
logger.debug("Working dir is {0}".format(working_dir))
if isinstance(target, JvmApp):
binary = target.binary
else:
binary = target
# This task is installed in the "run" goal.
# This means that, when invoked with ./pants run, it will run regardless of whether
# the target is a jvm target.
# As a result, not all targets passed here will have good defaults for extra_jvm_options
extra_jvm_options = binary.payload.get_field_value("extra_jvm_options", [])
# We can't throw if binary isn't a JvmBinary, because perhaps we were called on a
# python_binary, in which case we have to no-op and let python_run do its thing.
# TODO(benjy): Some more elegant way to coordinate how tasks claim targets.
if isinstance(binary, JvmBinary):
jvm = DistributionLocator.cached()
executor = CommandLineGrabber(jvm) if self.only_write_cmd_line else None
self.context.release_lock()
with self.context.new_workunit(name='run', labels=[WorkUnitLabel.RUN]):
result = jvm.execute_java(
classpath=self.classpath([target]),
main=self.get_options().main or binary.main,
executor=executor,
jvm_options=self.jvm_options + extra_jvm_options,
args=self.args,
cwd=working_dir,
synthetic_jar_dir=self.workdir,
create_synthetic_jar=self.synthetic_classpath
)
if self.only_write_cmd_line:
with safe_open(expand_path(self.only_write_cmd_line), 'w') as outfile:
outfile.write(' '.join(executor.cmd))
elif result != 0:
raise TaskError('java {} ... exited non-zero ({})'.format(binary.main, result),
exit_code=result)
def execute(self):
# The called binary may block for a while, allow concurrent pants activity during this pants
# idle period.
#
# TODO(John Sirois): refactor lock so that I can do:
# with self.context.lock.yield():
# - blocking code
#
# Currently re-acquiring the lock requires a path argument that was set up by the goal
# execution engine. I do not want task code to learn the lock location.
# http://jira.local.twitter.com/browse/AWESOME-1317
target = self.require_single_root_target()
working_dir = None
cwd_opt = self.get_options().cwd
if cwd_opt != _CWD_NOT_PRESENT:
working_dir = self.get_options().cwd
if not working_dir:
working_dir = target.address.spec_path
logger.debug("Working dir is {0}".format(working_dir))
if isinstance(target, JvmApp):
binary = target.binary
else:
binary = target
# We can't throw if binary isn't a JvmBinary, because perhaps we were called on a
# python_binary, in which case we have to no-op and let python_run do its thing.
# TODO(benjy): Some more elegant way to coordinate how tasks claim targets.
if isinstance(binary, JvmBinary):
executor = CommandLineGrabber(
) if self.only_write_cmd_line else None
self.context.release_lock()
exclusives_classpath = self.get_base_classpath_for_target(binary)
result = execute_java(
classpath=(self.classpath(
confs=self.confs,
exclusives_classpath=exclusives_classpath)),
main=binary.main,
executor=executor,
jvm_options=self.jvm_options,
args=self.args,
workunit_factory=self.context.new_workunit,
workunit_name='run',
workunit_labels=[WorkUnit.RUN],
cwd=working_dir,
)
if self.only_write_cmd_line:
with safe_open(expand_path(self.only_write_cmd_line),
'w') as outfile:
outfile.write(' '.join(executor.cmd))
elif result != 0:
raise TaskError('java %s ... exited non-zero (%i)' %
(binary.main, result),
exit_code=result)
def execute(self):
# The called binary may block for a while, allow concurrent pants activity during this pants
# idle period.
#
# TODO(John Sirois): refactor lock so that I can do:
# with self.context.lock.yield():
# - blocking code
#
# Currently re-acquiring the lock requires a path argument that was set up by the goal
# execution engine. I do not want task code to learn the lock location.
# http://jira.local.twitter.com/browse/AWESOME-1317
target = self.require_single_root_target()
working_dir = None
cwd_opt = self.get_options().cwd
if cwd_opt != _CWD_NOT_PRESENT:
working_dir = self.get_options().cwd
if not working_dir:
working_dir = target.address.spec_path
logger.debug ("Working dir is {0}".format(working_dir))
if isinstance(target, JvmApp):
binary = target.binary
else:
binary = target
# We can't throw if binary isn't a JvmBinary, because perhaps we were called on a
# python_binary, in which case we have to no-op and let python_run do its thing.
# TODO(benjy): Some more elegant way to coordinate how tasks claim targets.
if isinstance(binary, JvmBinary):
executor = CommandLineGrabber() if self.only_write_cmd_line else None
self.context.release_lock()
exclusives_classpath = self.get_base_classpath_for_target(binary)
result = execute_java(
classpath=(self.classpath(confs=self.confs, exclusives_classpath=exclusives_classpath)),
main=binary.main,
executor=executor,
jvm_options=self.jvm_options,
args=self.args,
workunit_factory=self.context.new_workunit,
workunit_name='run',
workunit_labels=[WorkUnit.RUN],
cwd=working_dir,
)
if self.only_write_cmd_line:
with safe_open(expand_path(self.only_write_cmd_line), 'w') as outfile:
outfile.write(' '.join(executor.cmd))
elif result != 0:
raise TaskError('java %s ... exited non-zero (%i)' % (binary.main, result),
exit_code=result)
def execute(self):
# The called binary may block for a while, allow concurrent pants activity during this pants
# idle period.
#
# TODO(John Sirois): refactor lock so that I can do:
# with self.context.lock.yield():
# - blocking code
#
# Currently re-acquiring the lock requires a path argument that was set up by the goal
# execution engine. I do not want task code to learn the lock location.
# http://jira.local.twitter.com/browse/AWESOME-1317
target = self.require_single_root_target()
working_dir = None
cwd_opt = self.get_options().cwd
if cwd_opt != _CWD_NOT_PRESENT:
working_dir = self.get_options().cwd
if not working_dir:
working_dir = target.address.spec_path
logger.debug(f"Working dir is {working_dir}")
if isinstance(target, JvmApp):
binary = target.binary
else:
binary = target
# This task is installed in the "run" goal.
# This means that, when invoked with ./pants run, it will run regardless of whether
# the target is a jvm target.
# As a result, not all targets passed here will have good defaults for extra_jvm_options
extra_jvm_options = binary.payload.get_field_value(
"extra_jvm_options", [])
# We can't throw if binary isn't a JvmBinary, because perhaps we were called on a
# python_binary, in which case we have to no-op and let python_run do its thing.
# TODO(benjy): Some more elegant way to coordinate how tasks claim targets.
if isinstance(binary, JvmBinary):
platform = binary.runtime_platform
jvm = self.preferred_jvm_distribution([platform])
executor = CommandLineGrabber(
jvm) if self.only_write_cmd_line else None
self.context.release_lock()
with self.context.new_workunit(name="run",
labels=[WorkUnitLabel.RUN]):
result = jvm.execute_java(
classpath=self.classpath([target]),
main=self.get_options().main or binary.main,
executor=executor,
jvm_options=(self.jvm_options +
list(platform.jvm_options) +
list(extra_jvm_options)),
args=self.args,
cwd=working_dir,
synthetic_jar_dir=self.workdir,
create_synthetic_jar=self.synthetic_classpath,
)
if self.only_write_cmd_line:
with safe_open(expand_path(self.only_write_cmd_line),
"w") as outfile:
outfile.write(" ".join(executor.cmd))
elif result != 0:
raise TaskError(
f"java {binary.main} ... exited non-zero ({result})",
exit_code=result)
def test_env_var_expansion(self):
with self.root() as root:
with environment_as(A='B', C='D'):
self.assertEquals(os.path.join(root, 'B/D/E'), expand_path('$A/${C}/E'))
def test_user_expansion(self):
with environment_as(HOME='/tmp/jake'):
self.assertEquals('/tmp/jake/bob', expand_path('~/bob'))
def test_absolute(self):
self.assertEquals('/tmp/jake/bob', expand_path('/tmp/jake/bob'))
def test_dot_relative(self):
with self.root() as root:
self.assertEquals(os.path.join(root, 'a'), expand_path('./a'))
def test_pure_relative(self):
with self.root() as root:
self.assertEqual(os.path.join(root, 'a'), expand_path('a'))
def test_user_expansion(self):
with environment_as(HOME="/tmp/jake"):
self.assertEqual("/tmp/jake/bob", expand_path("~/bob"))
def test_absolute(self):
self.assertEquals('/tmp/jake/bob', expand_path('/tmp/jake/bob'))
def test_dot_relative(self):
with self.root() as root:
self.assertEquals(os.path.join(root, 'a'), expand_path('./a'))
def test_pure_relative(self):
with self.root() as root:
self.assertEqual(os.path.join(root, 'a'), expand_path('a'))
def test_dot_relative(self):
with self.root() as root:
self.assertEqual(os.path.join(root, "a"), expand_path("./a"))
def test_absolute(self):
self.assertEqual("/tmp/jake/bob", expand_path("/tmp/jake/bob"))
def test_user_expansion(self):
with environment_as(HOME='/tmp/jake'):
self.assertEquals('/tmp/jake/bob', expand_path('~/bob'))
def test_env_var_expansion(self):
with self.root() as root:
with environment_as(A="B", C="D"):
self.assertEqual(os.path.join(root, "B/D/E"),
expand_path("$A/${C}/E"))
def test_env_var_expansion(self):
with self.root() as root:
with environment_as(A='B', C='D'):
self.assertEquals(os.path.join(root, 'B/D/E'), expand_path('$A/${C}/E'))
