def setUp(self):
self.mock_handler_inst = mock.Mock()
self.mock_runner_factory = mock.Mock(
side_effect=Exception('this should never be called'))
self.mock_handler_class = mock.Mock(
return_value=self.mock_handler_inst)
self.lock = threading.RLock()
@contextmanager
def lock():
with self.lock:
yield
self.after_request_callback_calls = 0
def after_request_callback():
self.after_request_callback_calls += 1
with mock.patch.object(PailgunServer, 'server_bind'), \
mock.patch.object(PailgunServer, 'server_activate'):
self.server = PailgunServer(
server_address=('0.0.0.0', 0),
runner_factory=self.mock_runner_factory,
handler_class=self.mock_handler_class,
lifecycle_lock=lock,
request_complete_callback=after_request_callback)
def setUp(self):
self.mock_handler_inst = unittest.mock.Mock()
# Add a fake environment for this to not timeout.
self.fake_environment = {"PANTSD_REQUEST_TIMEOUT_LIMIT": "-1"}
self.mock_handler_inst.parsed_request.return_value = (None, None, [], self.fake_environment)
self.mock_runner_factory = unittest.mock.Mock(
side_effect=Exception("this should never be called")
)
self.mock_handler_class = unittest.mock.Mock(return_value=self.mock_handler_inst)
self.lock = threading.RLock()
@contextmanager
def lock():
with self.lock:
yield
self.after_request_callback_calls = 0
def after_request_callback():
self.after_request_callback_calls += 1
with unittest.mock.patch.object(PailgunServer, "server_bind"), unittest.mock.patch.object(
PailgunServer, "server_activate"
):
self.server = PailgunServer(
server_address=("0.0.0.0", 0),
runner_factory=self.mock_runner_factory,
handler_class=self.mock_handler_class,
lifecycle_lock=lock,
request_complete_callback=after_request_callback,
)
def _setup_pailgun(self):
"""Sets up a PailgunServer instance."""
# Constructs and returns a runnable PantsRunner.
def runner_factory(sock, arguments, environment):
exiter = self._exiter_class(sock)
build_graph = None
self._logger.debug('execution commandline: %s', arguments)
if self._scheduler_service:
# N.B. This parses sys.argv by way of OptionsInitializer/OptionsBootstrapper prior to
# the main pants run to derive spec_roots for caching in the underlying scheduler.
spec_roots = self._parse_commandline_to_spec_roots(
args=arguments)
self._logger.debug('parsed spec_roots: %s', spec_roots)
try:
self._logger.debug('requesting BuildGraph from %s',
self._scheduler_service)
# N.B. This call is made in the pre-fork daemon context for reach and reuse of the
# resident scheduler for BuildGraph construction.
build_graph = self._scheduler_service.get_build_graph(
spec_roots)
except Exception:
self._logger.warning(
'encountered exception during SchedulerService.get_build_graph():\n%s',
traceback.format_exc())
return self._runner_class(sock, exiter, arguments, environment,
build_graph)
return PailgunServer(self._bind_addr, runner_factory)
def _setup_pailgun(self):
"""Sets up a PailgunServer instance."""
# Constructs and returns a runnable PantsRunner.
def runner_factory(sock, arguments, environment):
exiter = self._exiter_class(sock)
return self._runner_class(sock, exiter, arguments, environment)
return PailgunServer(self._bind_addr, runner_factory)
def setUp(self):
self.mock_handler_inst = mock.Mock()
self.mock_runner_factory = mock.Mock(side_effect=Exception('this should never be called'))
self.mock_handler_class = mock.Mock(return_value=self.mock_handler_inst)
with mock.patch.object(PailgunServer, 'server_bind'), \
mock.patch.object(PailgunServer, 'server_activate'):
self.server = PailgunServer(
server_address=('0.0.0.0', 0),
runner_factory=self.mock_runner_factory,
handler_class=self.mock_handler_class
)
def _setup_pailgun(self):
"""Sets up a PailgunServer instance."""
# Constructs and returns a runnable PantsRunner.
def runner_factory(sock, arguments, environment):
return self._runner_class.create(sock, arguments, environment,
self._scheduler_service)
# Plumb the daemon's lifecycle lock to the `PailgunServer` to safeguard teardown.
@contextmanager
def lifecycle_lock():
with self.lifecycle_lock:
yield
return PailgunServer(self._bind_addr, runner_factory, lifecycle_lock)
def _setup_pailgun(self):
"""Sets up a PailgunServer instance."""
# Constructs and returns a runnable PantsRunner.
def runner_factory(sock, arguments, environment):
exiter = self._exiter_class(sock)
graph_helper = None
deferred_exc = None
self._logger.debug('execution commandline: %s', arguments)
options_bootstrapper = OptionsBootstrapper(args=arguments)
build_config = BuildConfigInitializer.get(options_bootstrapper)
options = OptionsInitializer.create(options_bootstrapper, build_config)
graph_helper, target_roots = None, None
try:
self._logger.debug('warming the product graph via %s', self._scheduler_service)
# N.B. This call is made in the pre-fork daemon context for reach and reuse of the
# resident scheduler.
graph_helper, target_roots = self._scheduler_service.warm_product_graph(
options,
self._target_roots_calculator
)
except Exception:
deferred_exc = sys.exc_info()
self._logger.warning(
'encountered exception during SchedulerService.warm_product_graph(), deferring:\n%s',
''.join(traceback.format_exception(*deferred_exc))
)
return self._runner_class(
sock,
exiter,
arguments,
environment,
target_roots,
graph_helper,
self.fork_lock,
deferred_exc
)
# Plumb the daemon's lifecycle lock to the `PailgunServer` to safeguard teardown.
@contextmanager
def lifecycle_lock():
with self.lifecycle_lock:
yield
return PailgunServer(self._bind_addr, runner_factory, lifecycle_lock)
def _setup_pailgun(self):
"""Sets up a PailgunServer instance."""
# Constructs and returns a runnable PantsRunner.
def runner_factory(sock, arguments, environment):
exiter = self._exiter_class(sock)
graph_helper = None
deferred_exc = None
# Capture the size of the graph prior to any warming, for stats.
preceding_graph_size = self._scheduler_service.product_graph_len()
self._logger.debug('resident graph size: %s', preceding_graph_size)
self._logger.debug('execution commandline: %s', arguments)
options, _ = OptionsInitializer(
OptionsBootstrapper(args=arguments)).setup(init_logging=False)
target_roots = self._target_roots_calculator.create(
options,
change_calculator=self._scheduler_service.change_calculator)
try:
self._logger.debug('warming the product graph via %s',
self._scheduler_service)
# N.B. This call is made in the pre-fork daemon context for reach and reuse of the
# resident scheduler.
graph_helper = self._scheduler_service.warm_product_graph(
target_roots)
except Exception:
deferred_exc = sys.exc_info()
self._logger.warning(
'encountered exception during SchedulerService.warm_product_graph(), deferring:\n%s',
''.join(traceback.format_exception(*deferred_exc)))
return self._runner_class(sock, exiter, arguments, environment,
target_roots, graph_helper,
self.fork_lock, preceding_graph_size,
deferred_exc)
# Plumb the daemon's lifecycle lock to the `PailgunServer` to safeguard teardown.
@contextmanager
def lifecycle_lock():
with self.lifecycle_lock:
yield
return PailgunServer(self._bind_addr, runner_factory, lifecycle_lock)
def _setup_pailgun(self):
"""Sets up a PailgunServer instance."""
# Constructs and returns a runnable PantsRunner.
def runner_factory(sock, arguments, environment):
exiter = self._exiter_class(sock)
graph_helper = None
deferred_exc = None
self._logger.debug('execution commandline: %s', arguments)
if self._scheduler_service:
# N.B. This parses sys.argv by way of OptionsInitializer/OptionsBootstrapper prior to
# the main pants run to derive target roots for caching in the underlying product graph.
target_roots = self._target_roots_class.create(
args=arguments,
change_calculator=self._scheduler_service.change_calculator
)
try:
self._logger.debug('warming the product graph via %s', self._scheduler_service)
# N.B. This call is made in the pre-fork daemon context for reach and reuse of the
# resident scheduler.
graph_helper = self._scheduler_service.warm_product_graph(target_roots)
except Exception:
deferred_exc = sys.exc_info()
self._logger.warning(
'encountered exception during SchedulerService.warm_product_graph(), deferring:\n%s',
''.join(traceback.format_exception(*deferred_exc))
)
return self._runner_class(sock, exiter, arguments, environment, graph_helper, deferred_exc)
@contextmanager
def context_lock():
"""This lock is used to safeguard Pailgun request handling against a fork() with the
scheduler lock held by another thread (e.g. the FSEventService thread), which can
lead to a pailgun deadlock.
"""
if self._scheduler_service:
with self._scheduler_service.locked():
yield
else:
yield
return PailgunServer(self._bind_addr, runner_factory, context_lock)
def _setup_pailgun(self):
"""Sets up a PailgunServer instance."""
# Constructs and returns a runnable PantsRunner.
def runner_factory(sock, arguments, environment):
return self._runner_class.create(
sock,
arguments,
environment,
self.services,
self._scheduler_service,
)
# Plumb the daemon's lifecycle lock to the `PailgunServer` to safeguard teardown.
# This indirection exists to allow the server to be created before PantsService.setup
# has been called to actually initialize the `services` field.
@contextmanager
def lifecycle_lock():
with self.services.lifecycle_lock:
yield
return PailgunServer(self._bind_addr, runner_factory, lifecycle_lock)
