def set_up(self, test_case):
super(BrokerServiceHelper, self).set_up(test_case)
test_case.broker_service.startService()
# Use different reactor to simulate separate processes
self._connector = RemoteBrokerConnector(
FakeReactor(), test_case.broker_service.config)
deferred = self._connector.connect()
test_case.remote = test_case.successResultOf(deferred)
def run_task_handler(cls, args, reactor=None):
if reactor is None:
reactor = LandscapeReactor()
config = cls.config_factory()
config.load(args)
for directory in [config.package_directory, config.hash_id_directory]:
if not os.path.isdir(directory):
os.mkdir(directory)
program_name = cls.queue_name
lock_filename = os.path.join(config.package_directory,
program_name + ".lock")
try:
lock_path(lock_filename)
except LockError:
if config.quiet:
raise SystemExit()
raise SystemExit("error: package %s is already running"
% program_name)
words = re.findall("[A-Z][a-z]+", cls.__name__)
init_logging(config, "-".join(word.lower() for word in words))
# Setup our umask for Apt to use, this needs to setup file permissions to
# 0o644 so...
os.umask(0o022)
package_store = cls.package_store_class(config.store_filename)
# Delay importing of the facades so that we don't
# import Apt unless we need to.
from landscape.lib.apt.package.facade import AptFacade
package_facade = AptFacade()
def finish():
connector.disconnect()
reactor.call_later(0, reactor.stop)
def got_error(failure):
log_failure(failure)
finish()
connector = RemoteBrokerConnector(reactor, config, retry_on_reconnect=True)
remote = LazyRemoteBroker(connector)
handler = cls(package_store, package_facade, remote, config, reactor)
result = Deferred()
result.addCallback(lambda x: handler.run())
result.addCallback(lambda x: finish())
result.addErrback(got_error)
reactor.call_when_running(lambda: result.callback(None))
reactor.run()
return result
def set_up(self, test_case):
super(RemoteBrokerHelper, self).set_up(test_case)
self._publisher = ComponentPublisher(test_case.broker,
test_case.reactor,
test_case.config)
self._connector = RemoteBrokerConnector(test_case.reactor,
test_case.config)
self._publisher.start()
deferred = self._connector.connect()
test_case.remote = test_case.successResultOf(deferred)
def __init__(self,
reactor=reactor,
verbose=False,
config=None,
broker=None,
monitor=None,
manager=None,
enabled_daemons=None):
landscape_reactor = LandscapeReactor()
if enabled_daemons is None:
enabled_daemons = [Broker, Monitor, Manager]
if broker is None and Broker in enabled_daemons:
broker = Broker(RemoteBrokerConnector(landscape_reactor, config),
verbose=verbose,
config=config.config)
if monitor is None and Monitor in enabled_daemons:
monitor = Monitor(RemoteMonitorConnector(landscape_reactor,
config),
verbose=verbose,
config=config.config)
if manager is None and Manager in enabled_daemons:
manager = Manager(RemoteManagerConnector(landscape_reactor,
config),
verbose=verbose,
config=config.config)
self.broker = broker
self.monitor = monitor
self.manager = manager
self.daemons = [
daemon for daemon in [self.broker, self.monitor, self.manager]
if daemon
]
self.reactor = reactor
self._checking = None
self._stopping = False
signal.signal(
signal.SIGUSR1, lambda signal, frame: reactor.callFromThread(
self._notify_rotate_logs))
if config is not None and config.clones > 0:
options = [
"--clones",
str(config.clones), "--start-clones-over",
str(config.start_clones_over)
]
for daemon in self.daemons:
daemon.options = options
self._ping_failures = {}
def startService(self):
"""Start the monitor."""
super(MonitorService, self).startService()
self.publisher.start()
def start_plugins(broker):
self.broker = broker
self.monitor.broker = broker
for plugin in self.plugins:
self.monitor.add(plugin)
return self.broker.register_client(self.service_name)
self.connector = RemoteBrokerConnector(self.reactor, self.config)
connected = self.connector.connect()
return connected.addCallback(start_plugins)
def test_wb_is_lazy(self):
"""
The L{LazyRemoteBroker} class doesn't initialize the actual remote
broker until one of its attributes gets actually accessed.
"""
reactor = FakeReactor()
connector = RemoteBrokerConnector(reactor, self.broker_service.config)
self.broker = LazyRemoteBroker(connector)
self.assertIs(self.broker._remote, None)
def close_connection(result):
self.assertTrue(result)
connector.disconnect()
result = self.broker.ping()
return result.addCallback(close_connection)
def test_start_stop(self):
"""
The L{BrokerService.startService} method makes the process start
listening to the broker socket, and starts the L{Exchanger} and
the L{Pinger} as well.
"""
self.service.exchanger.start = Mock()
self.service.pinger.start = Mock()
self.service.exchanger.stop = Mock()
self.service.startService()
reactor = FakeReactor()
connector = RemoteBrokerConnector(reactor, self.config)
connected = connector.connect()
connected.addCallback(lambda remote: remote.get_server_uuid())
connected.addCallback(lambda x: connector.disconnect())
connected.addCallback(lambda x: self.service.stopService())
self.service.exchanger.start.assert_called_with()
self.service.pinger.start.assert_called_with()
self.service.exchanger.stop.assert_called_with()
def startService(self):
"""Start the manager service.
This method does 3 things, in this order:
- Start listening for connections on the manager socket.
- Connect to the broker.
- Add all configured plugins, that will in turn register themselves.
"""
super(ManagerService, self).startService()
self.publisher.start()
def start_plugins(broker):
self.broker = broker
self.manager.broker = broker
for plugin in self.plugins:
self.manager.add(plugin)
return self.broker.register_client(self.service_name)
self.connector = RemoteBrokerConnector(self.reactor, self.config)
connected = self.connector.connect()
return connected.addCallback(start_plugins)