Your IP : 172.28.240.42
from twisted.internet.defer import maybeDeferred
from landscape.lib.log import log_failure
from landscape.amp import ComponentPublisher, ComponentConnector, remote
from landscape.monitor.plugin import MonitorPlugin
from landscape.user.changes import UserChanges
from landscape.user.provider import UserProvider
class UserMonitor(MonitorPlugin):
"""
A plugin which monitors the system user databases.
"""
persist_name = "users"
scope = "users"
run_interval = 3600 # 1 hour
name = "usermonitor"
def __init__(self, provider=None):
if provider is None:
provider = UserProvider()
self._provider = provider
self._publisher = None
def register(self, registry):
super(UserMonitor, self).register(registry)
self.call_on_accepted("users", self._run_detect_changes, None)
self._publisher = ComponentPublisher(self, self.registry.reactor,
self.registry.config)
self._publisher.start()
def stop(self):
"""Stop listening for incoming AMP connections."""
if self._publisher:
self._publisher.stop()
self._publisher = None
def _reset(self):
"""Reset user and group data."""
super(UserMonitor, self)._reset()
return self._run_detect_changes()
@remote
def detect_changes(self, operation_id=None):
return self.registry.broker.call_if_accepted(
"users", self._run_detect_changes, operation_id)
run = detect_changes
def _run_detect_changes(self, operation_id=None):
"""
If changes are detected an C{urgent-exchange} is fired to send
updates to the server immediately.
@param operation_id: When present it will be included in the
C{operation-id} field.
"""
from landscape.manager.usermanager import RemoteUserManagerConnector
user_manager_connector = RemoteUserManagerConnector(
self.registry.reactor, self.registry.config)
# We'll skip checking the locked users if we're in monitor-only mode.
if getattr(self.registry.config, "monitor_only", False):
result = maybeDeferred(self._detect_changes,
[], operation_id)
else:
def get_locked_usernames(user_manager):
return user_manager.get_locked_usernames()
def disconnect(locked_usernames):
user_manager_connector.disconnect()
return locked_usernames
result = user_manager_connector.connect()
result.addCallback(get_locked_usernames)
result.addCallback(disconnect)
result.addCallback(self._detect_changes, operation_id)
result.addErrback(lambda f: self._detect_changes([], operation_id))
return result
def _detect_changes(self, locked_users, operation_id=None):
def update_snapshot(result):
changes.snapshot()
return result
def log_error(result):
log_failure(result, "Error occured calling send_message in "
"_detect_changes")
self._provider.locked_users = locked_users
changes = UserChanges(self._persist, self._provider)
message = changes.create_diff()
if message:
message["type"] = "users"
if operation_id:
message["operation-id"] = operation_id
result = self.registry.broker.send_message(
message, self._session_id, urgent=True)
result.addCallback(update_snapshot)
result.addErrback(log_error)
return result
class RemoteUserMonitorConnector(ComponentConnector):
component = UserMonitor