def run(self, start_time: float) -> ExitCode:
self.scrub_pythonpath()
options_bootstrapper = OptionsBootstrapper.create(env=self.env,
args=self.args,
allow_pantsrc=True)
bootstrap_options = options_bootstrapper.bootstrap_options
global_bootstrap_options = bootstrap_options.for_global_scope()
# Initialize the workdir early enough to ensure that logging has a destination.
workdir_src = init_workdir(global_bootstrap_options)
ExceptionSink.reset_log_location(workdir_src)
# We enable logging here, and everything before it will be routed through regular
# Python logging.
setup_logging(global_bootstrap_options)
ExceptionSink.reset_should_print_backtrace_to_terminal(
global_bootstrap_options.print_exception_stacktrace)
if self._should_run_with_pantsd(global_bootstrap_options):
try:
return RemotePantsRunner(self.args, self.env,
options_bootstrapper).run(start_time)
except RemotePantsRunner.Fallback as e:
logger.warning(
"Client exception: {!r}, falling back to non-daemon mode".
format(e))
# N.B. Inlining this import speeds up the python thin client run by about 100ms.
from pants.bin.local_pants_runner import LocalPantsRunner
runner = LocalPantsRunner.create(
env=self.env, options_bootstrapper=options_bootstrapper)
return runner.run(start_time)
def run(self):
# Register our exiter at the beginning of the run() method so that any code in this process from
# this point onwards will use that exiter in the case of a fatal error.
ExceptionSink.reset_exiter(self._exiter)
options_bootstrapper = OptionsBootstrapper(env=self._env,
args=self._args)
bootstrap_options = options_bootstrapper.get_bootstrap_options()
global_bootstrap_options = bootstrap_options.for_global_scope()
ExceptionSink.reset_should_print_backtrace_to_terminal(
global_bootstrap_options.print_exception_stacktrace)
ExceptionSink.reset_log_location(
global_bootstrap_options.pants_workdir)
if global_bootstrap_options.enable_pantsd:
try:
return RemotePantsRunner(self._exiter, self._args, self._env,
bootstrap_options).run()
except RemotePantsRunner.Fallback as e:
logger.warn(
'caught client exception: {!r}, falling back to non-daemon mode'
.format(e))
# N.B. Inlining this import speeds up the python thin client run by about 100ms.
from pants.bin.local_pants_runner import LocalPantsRunner
runner = LocalPantsRunner.create(
self._exiter,
self._args,
self._env,
options_bootstrapper=options_bootstrapper)
runner.set_start_time(self._start_time)
return runner.run()
def run_sync(self):
"""Synchronously run pantsd."""
# Switch log output to the daemon's log stream from here forward.
self._close_stdio()
with self._pantsd_logging() as log_stream:
# Register an exiter using os._exit to ensure we only close stdio streams once.
ExceptionSink.reset_exiter(Exiter(exiter=os._exit))
# We don't have any stdio streams to log to anymore, but we can get tracebacks of the pantsd
# process by tailing the pantsd log and sending it SIGUSR2.
ExceptionSink.reset_interactive_output_stream(log_stream)
# Reset the log location and the backtrace preference from the global bootstrap options.
global_bootstrap_options = self._bootstrap_options.for_global_scope()
ExceptionSink.reset_should_print_backtrace_to_terminal(
global_bootstrap_options.print_exception_stacktrace)
ExceptionSink.reset_log_location(global_bootstrap_options.pants_workdir)
self._logger.info('pantsd starting, log level is {}'.format(self._log_level))
self._native.set_panic_handler()
# Set the process name in ps output to 'pantsd' vs './pants compile src/etc:: -ldebug'.
set_process_title('pantsd [{}]'.format(self._build_root))
# Write service socket information to .pids.
self._write_named_sockets(self._services.port_map)
# Enter the main service runner loop.
self._setup_services(self._services)
self._run_services(self._services)
def run_sync(self):
"""Synchronously run pantsd."""
os.environ.pop("PYTHONPATH")
# Switch log output to the daemon's log stream from here forward.
self._close_stdio()
with self._pantsd_logging() as log_stream:
# We don't have any stdio streams to log to anymore, so we log to a file.
# We don't override the faulthandler destination because the stream we get will proxy things
# via the rust logging code, and faulthandler needs to be writing directly to a real file
# descriptor. When pantsd logging was originally initialised, we already set up faulthandler
# to log to the correct file descriptor, so don't override it.
#
# We can get tracebacks of the pantsd process by tailing the pantsd log and sending it
# SIGUSR2.
ExceptionSink.reset_interactive_output_stream(
log_stream,
override_faulthandler_destination=False,
)
# Reset the log location and the backtrace preference from the global bootstrap options.
global_bootstrap_options = self._bootstrap_options.for_global_scope(
)
ExceptionSink.reset_should_print_backtrace_to_terminal(
global_bootstrap_options.print_exception_stacktrace)
ExceptionSink.reset_log_location(
global_bootstrap_options.pants_workdir)
self._native.set_panic_handler()
# Set the process name in ps output to 'pantsd' vs './pants compile src/etc:: -ldebug'.
set_process_title(f"pantsd [{self._build_root}]")
# Write our pid and the server's port to .pids. Order matters a bit here, because
# technically all that is necessary to connect is the port, and Services are lazily
# initialized by the core when a connection is established. Our pid needs to be on
# disk before that happens.
self._initialize_pid()
self._write_nailgun_port()
# Check periodically whether the core is valid, and exit if it is not.
while self._core.is_valid():
time.sleep(self.JOIN_TIMEOUT_SECONDS)
# We're exiting: join the server to avoid interrupting ongoing runs.
self._logger.info(
"waiting for ongoing runs to complete before exiting...")
self._native.nailgun_server_await_shutdown(self._server)
self._logger.info("exiting.")
def run(self):
# Register our exiter at the beginning of the run() method so that any code in this process from
# this point onwards will use that exiter in the case of a fatal error.
ExceptionSink.reset_exiter(self._exiter)
options_bootstrapper = OptionsBootstrapper.create(env=self._env,
args=self._args)
bootstrap_options = options_bootstrapper.bootstrap_options
global_bootstrap_options = bootstrap_options.for_global_scope()
# We enable Rust logging here,
# and everything before it will be routed through regular Python logging.
self._enable_rust_logging(global_bootstrap_options)
ExceptionSink.reset_should_print_backtrace_to_terminal(
global_bootstrap_options.print_exception_stacktrace)
ExceptionSink.reset_log_location(
global_bootstrap_options.pants_workdir)
for message_regexp in global_bootstrap_options.ignore_pants_warnings:
warnings.filterwarnings(action='ignore', message=message_regexp)
# TODO https://github.com/pantsbuild/pants/issues/7205
if self._should_run_with_pantsd(global_bootstrap_options):
try:
return RemotePantsRunner(self._exiter, self._args, self._env,
options_bootstrapper).run()
except RemotePantsRunner.Fallback as e:
logger.warn(
'caught client exception: {!r}, falling back to non-daemon mode'
.format(e))
# N.B. Inlining this import speeds up the python thin client run by about 100ms.
from pants.bin.local_pants_runner import LocalPantsRunner
if self.will_terminate_pantsd():
logger.debug("Pantsd terminating goal detected: {}".format(
self._args))
runner = LocalPantsRunner.create(
self._exiter,
self._args,
self._env,
options_bootstrapper=options_bootstrapper)
runner.set_start_time(self._start_time)
return runner.run()
def run_sync(self):
"""Synchronously run pantsd."""
os.environ.pop("PYTHONPATH")
# Switch log output to the daemon's log stream from here forward.
# Also, register an exiter using os._exit to ensure we only close stdio streams once.
self._close_stdio()
with self._pantsd_logging() as (log_stream,
log_filename), ExceptionSink.exiter_as(
lambda _: Exiter(exiter=os._exit)):
# We don't have any stdio streams to log to anymore, so we log to a file.
# We don't override the faulthandler destination because the stream we get will proxy things
# via the rust logging code, and faulthandler needs to be writing directly to a real file
# descriptor. When pantsd logging was originally initialised, we already set up faulthandler
# to log to the correct file descriptor, so don't override it.
#
# We can get tracebacks of the pantsd process by tailing the pantsd log and sending it
# SIGUSR2.
ExceptionSink.reset_interactive_output_stream(
log_stream,
override_faulthandler_destination=False,
)
# Reset the log location and the backtrace preference from the global bootstrap options.
global_bootstrap_options = self._bootstrap_options.for_global_scope(
)
ExceptionSink.reset_should_print_backtrace_to_terminal(
global_bootstrap_options.print_exception_stacktrace)
ExceptionSink.reset_log_location(
global_bootstrap_options.pants_workdir)
self._native.set_panic_handler()
# Set the process name in ps output to 'pantsd' vs './pants compile src/etc:: -ldebug'.
set_process_title(f"pantsd [{self._build_root}]")
# Write service socket information to .pids.
self._write_named_sockets(self._services.port_map)
# Enter the main service runner loop.
self._setup_services(self._services)
self._run_services(self._services)
def run(self, start_time: float) -> ExitCode:
self.scrub_pythonpath()
options_bootstrapper = OptionsBootstrapper.create(env=self.env, args=self.args)
bootstrap_options = options_bootstrapper.bootstrap_options
global_bootstrap_options = bootstrap_options.for_global_scope()
# Initialize the workdir early enough to ensure that logging has a destination.
workdir_src = init_workdir(global_bootstrap_options)
ExceptionSink.reset_log_location(workdir_src)
# We enable logging here, and everything before it will be routed through regular
# Python logging.
setup_logging(global_bootstrap_options)
ExceptionSink.reset_should_print_backtrace_to_terminal(
global_bootstrap_options.print_exception_stacktrace
)
# TODO: When we remove this deprecation, we'll change the default for the option to true.
deprecated_conditional(
lambda: global_bootstrap_options.is_default("enable_pantsd"),
removal_version="1.30.0.dev0",
entity_description="--enable-pantsd defaulting to False",
hint_message=(
"Pantsd improves runtime performance and will be enabled by default in the 1.30.x "
"stable releases. To prepare for that change, we recommend setting the "
"`[GLOBAL] enable_pantsd` setting to `True` in your pants.toml or pants.ini file."
),
)
if self._should_run_with_pantsd(global_bootstrap_options):
try:
return RemotePantsRunner(self.args, self.env, options_bootstrapper).run(start_time)
except RemotePantsRunner.Fallback as e:
logger.warning("Client exception: {!r}, falling back to non-daemon mode".format(e))
# N.B. Inlining this import speeds up the python thin client run by about 100ms.
from pants.bin.local_pants_runner import LocalPantsRunner
runner = LocalPantsRunner.create(env=self.env, options_bootstrapper=options_bootstrapper)
return runner.run(start_time)
def run(self):
self.scrub_pythonpath()
options_bootstrapper = OptionsBootstrapper.create(env=self._env,
args=self._args)
bootstrap_options = options_bootstrapper.bootstrap_options
global_bootstrap_options = bootstrap_options.for_global_scope()
# Initialize the workdir early enough to ensure that logging has a destination.
workdir_src = init_workdir(global_bootstrap_options)
ExceptionSink.reset_log_location(workdir_src)
# We enable Rust logging here,
# and everything before it will be routed through regular Python logging.
self._enable_rust_logging(global_bootstrap_options)
ExceptionSink.reset_should_print_backtrace_to_terminal(
global_bootstrap_options.print_exception_stacktrace)
ExceptionSink.reset_log_location(
global_bootstrap_options.pants_workdir)
# TODO https://github.com/pantsbuild/pants/issues/7205
if self._should_run_with_pantsd(global_bootstrap_options):
try:
return RemotePantsRunner(self._exiter, self._args, self._env,
options_bootstrapper).run()
except RemotePantsRunner.Fallback as e:
logger.warning(
"caught client exception: {!r}, falling back to non-daemon mode"
.format(e))
# N.B. Inlining this import speeds up the python thin client run by about 100ms.
from pants.bin.local_pants_runner import LocalPantsRunner
if self.will_terminate_pantsd():
logger.debug("Pantsd terminating goal detected: {}".format(
self._args))
runner = LocalPantsRunner.create(
self._args, self._env, options_bootstrapper=options_bootstrapper)
runner.set_start_time(self._start_time)
return runner.run()
def run_sync(self):
"""Synchronously run pantsd."""
# Switch log output to the daemon's log stream from here forward.
self._close_stdio()
with self._pantsd_logging() as (log_stream, log_filename):
# Register an exiter using os._exit to ensure we only close stdio streams once.
ExceptionSink.reset_exiter(Exiter(exiter=os._exit))
# We don't have any stdio streams to log to anymore, so we log to a file.
# We don't override the faulthandler destination because the stream we get will proxy things
# via the rust logging code, and faulthandler needs to be writing directly to a real file
# descriptor. When pantsd logging was originally initialised, we already set up faulthandler
# to log to the correct file descriptor, so don't override it.
#
# We can get tracebacks of the pantsd process by tailing the pantsd log and sending it
# SIGUSR2.
ExceptionSink.reset_interactive_output_stream(
log_stream,
override_faulthandler_destination=False,
)
# Reset the log location and the backtrace preference from the global bootstrap options.
global_bootstrap_options = self._bootstrap_options.for_global_scope()
ExceptionSink.reset_should_print_backtrace_to_terminal(
global_bootstrap_options.print_exception_stacktrace)
ExceptionSink.reset_log_location(global_bootstrap_options.pants_workdir)
self._native.set_panic_handler()
# Set the process name in ps output to 'pantsd' vs './pants compile src/etc:: -ldebug'.
set_process_title('pantsd [{}]'.format(self._build_root))
# Write service socket information to .pids.
self._write_named_sockets(self._services.port_map)
# Enter the main service runner loop.
self._setup_services(self._services)
self._run_services(self._services)
def run(self):
# Register our exiter at the beginning of the run() method so that any code in this process from
# this point onwards will use that exiter in the case of a fatal error.
ExceptionSink.reset_exiter(self._exiter)
options_bootstrapper = OptionsBootstrapper.create(env=self._env, args=self._args)
bootstrap_options = options_bootstrapper.bootstrap_options
global_bootstrap_options = bootstrap_options.for_global_scope()
# We enable Rust logging here,
# and everything before it will be routed through regular Python logging.
self._enable_rust_logging(global_bootstrap_options)
ExceptionSink.reset_should_print_backtrace_to_terminal(global_bootstrap_options.print_exception_stacktrace)
ExceptionSink.reset_log_location(global_bootstrap_options.pants_workdir)
for message_regexp in global_bootstrap_options.ignore_pants_warnings:
warnings.filterwarnings(action='ignore', message=message_regexp)
if global_bootstrap_options.enable_pantsd:
try:
return RemotePantsRunner(self._exiter, self._args, self._env, options_bootstrapper).run()
except RemotePantsRunner.Fallback as e:
logger.warn('caught client exception: {!r}, falling back to non-daemon mode'.format(e))
# N.B. Inlining this import speeds up the python thin client run by about 100ms.
from pants.bin.local_pants_runner import LocalPantsRunner
runner = LocalPantsRunner.create(
self._exiter,
self._args,
self._env,
options_bootstrapper=options_bootstrapper
)
runner.set_start_time(self._start_time)
return runner.run()
