← Back to branch summary

~tribaal/+junk/landscape-client-14.12-0ubuntu0.10.04

« back to all changes in this revision

Viewing changes to landscape/monitor/usermonitor.py

  • Committer: Chris Glass
  • Date: 2014-12-15 06:54:28 UTC
  • Revision ID: chris.glass@canonical.com-20141215065428-e23g6yyvrsvyb656
Imported pristine tarball.

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/monitor/usermonitor.py
 
1
from twisted.internet.defer import maybeDeferred
 
2
 
 
3
from landscape.lib.log import log_failure
 
4
from landscape.amp import ComponentPublisher, ComponentConnector, remote
 
5
 
 
6
from landscape.monitor.plugin import MonitorPlugin
 
7
from landscape.user.changes import UserChanges
 
8
from landscape.user.provider import UserProvider
 
9
 
 
10
 
 
11
class UserMonitor(MonitorPlugin):
 
12
    """
 
13
    A plugin which monitors the system user databases.
 
14
    """
 
15
 
 
16
    persist_name = "users"
 
17
    scope = "users"
 
18
    run_interval = 3600  # 1 hour
 
19
    name = "usermonitor"
 
20
 
 
21
    def __init__(self, provider=None):
 
22
        if provider is None:
 
23
            provider = UserProvider()
 
24
        self._provider = provider
 
25
        self._publisher = None
 
26
 
 
27
    def register(self, registry):
 
28
        super(UserMonitor, self).register(registry)
 
29
 
 
30
        self.call_on_accepted("users", self._run_detect_changes, None)
 
31
 
 
32
        self._publisher = ComponentPublisher(self, self.registry.reactor,
 
33
                                             self.registry.config)
 
34
        self._publisher.start()
 
35
 
 
36
    def stop(self):
 
37
        """Stop listening for incoming AMP connections."""
 
38
        if self._publisher:
 
39
            self._publisher.stop()
 
40
            self._publisher = None
 
41
 
 
42
    def _reset(self):
 
43
        """Reset user and group data."""
 
44
        super(UserMonitor, self)._reset()
 
45
        return self._run_detect_changes()
 
46
 
 
47
    @remote
 
48
    def detect_changes(self, operation_id=None):
 
49
        return self.registry.broker.call_if_accepted(
 
50
            "users", self._run_detect_changes, operation_id)
 
51
 
 
52
    run = detect_changes
 
53
 
 
54
    def _run_detect_changes(self, operation_id=None):
 
55
        """
 
56
        If changes are detected an C{urgent-exchange} is fired to send
 
57
        updates to the server immediately.
 
58
 
 
59
        @param operation_id: When present it will be included in the
 
60
            C{operation-id} field.
 
61
        """
 
62
        from landscape.manager.usermanager import RemoteUserManagerConnector
 
63
        user_manager_connector = RemoteUserManagerConnector(
 
64
            self.registry.reactor, self.registry.config)
 
65
 
 
66
        # We'll skip checking the locked users if we're in monitor-only mode.
 
67
        if getattr(self.registry.config, "monitor_only", False):
 
68
            result = maybeDeferred(self._detect_changes,
 
69
                                   [], operation_id)
 
70
        else:
 
71
 
 
72
            def get_locked_usernames(user_manager):
 
73
                return user_manager.get_locked_usernames()
 
74
 
 
75
            def disconnect(locked_usernames):
 
76
                user_manager_connector.disconnect()
 
77
                return locked_usernames
 
78
 
 
79
            result = user_manager_connector.connect()
 
80
            result.addCallback(get_locked_usernames)
 
81
            result.addCallback(disconnect)
 
82
            result.addCallback(self._detect_changes, operation_id)
 
83
            result.addErrback(lambda f: self._detect_changes([], operation_id))
 
84
        return result
 
85
 
 
86
    def _detect_changes(self, locked_users, operation_id=None):
 
87
 
 
88
        def update_snapshot(result):
 
89
            changes.snapshot()
 
90
            return result
 
91
 
 
92
        def log_error(result):
 
93
            log_failure(result, "Error occured calling send_message in "
 
94
                        "_detect_changes")
 
95
 
 
96
        self._provider.locked_users = locked_users
 
97
        changes = UserChanges(self._persist, self._provider)
 
98
        message = changes.create_diff()
 
99
 
 
100
        if message:
 
101
            message["type"] = "users"
 
102
            if operation_id:
 
103
                message["operation-id"] = operation_id
 
104
            result = self.registry.broker.send_message(
 
105
                message, self._session_id, urgent=True)
 
106
            result.addCallback(update_snapshot)
 
107
            result.addErrback(log_error)
 
108
            return result
 
109
 
 
110
 
 
111
class RemoteUserMonitorConnector(ComponentConnector):
 
112
 
 
113
    component = UserMonitor