|
|
| System | : | Linux MiraNet 3.0.0-14-generic-pae #23-Ubuntu SMP Mon Nov 21 22:07:10 UTC 2011 i686 |
|---|
| Software | : | Apache. PHP/5.3.6-13ubuntu3.10 |
|---|
| ID | : | uid=65534(nobody) gid=65534(nogroup) groups=65534(nogroup)
|
|---|
|
| Safe Mode | : | OFF |
|---|
| Open_Basedir | : | OFF |
|---|
| Freespace | : | 23.98 GB of 70.42 GB (34.06%) |
|---|
|
|
MySQL: ON MSSQL: OFF Oracle: OFF PostgreSQL: OFF Curl: OFF Sockets: ON Fetch: OFF Wget: ON Perl: ON |
|
Disabled Functions: pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,
|
[ System Info ]
[ Processes ]
[ SQL Manager ]
[ Eval ]
[ Encoder ]
[ Mailer ]
[ Back Connection ]
[ Backdoor Server ]
[ Kernel Exploit Search ]
[ MD5 Decrypter ]
[ Reverse IP ]
[ Kill Shell ]
[ FTP Brute-Force ]
|
|
/
usr/
share/
pyshared/
landscape/
monitor/
- drwxr-xr-x
|
Viewing file:  usermonitor.py (4.22 KB) -rw-r--r--Select action/file-type:  ( +) |  ( +) |  ( +) | Code ( +) | Session ( +) |  ( +) | SDB ( +) |  ( +) |  ( +) |  ( +) |  ( +) |  ( +) |
import os
from twisted.internet.defer import maybeDeferred
from landscape.lib.log import log_failure
from landscape.lib.amp import RemoteObject
from landscape.amp import (
ComponentProtocol, ComponentProtocolFactory, RemoteComponentConnector)
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"
run_interval = 3600 # 1 hour
name = "usermonitor"
def __init__(self, provider=None):
if provider is None:
provider = UserProvider()
self._provider = provider
self._port = None
def register(self, registry):
super(UserMonitor, self).register(registry)
self.call_on_accepted("users", self._run_detect_changes, None)
factory = UserMonitorProtocolFactory(object=self)
socket = os.path.join(self.registry.config.sockets_path,
self.name + ".sock")
self._port = self.registry.reactor.listen_unix(socket, factory)
def stop(self):
"""Stop listening for incoming AMP connections."""
if self._port:
self._port.stopListening()
self._port = None
def _resynchronize(self):
"""Resynchronize user and group data."""
super(UserMonitor, self)._resynchronize()
return self._run_detect_changes()
def run(self, operation_id=None):
return self.registry.broker.call_if_accepted(
"users", self._run_detect_changes, operation_id)
detect_changes = run
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, urgent=True)
result.addCallback(update_snapshot)
result.addErrback(log_error)
return result
class UserMonitorProtocol(ComponentProtocol):
"""L{AMP}-based protocol for calling L{UserMonitor}'s methods remotely."""
methods = ["detect_changes"]
class UserMonitorProtocolFactory(ComponentProtocolFactory):
protocol = UserMonitorProtocol
class RemoteUserMonitor(RemoteObject):
"""A connected remote L{UserMonitor}."""
class RemoteUserMonitorConnector(RemoteComponentConnector):
factory = ComponentProtocolFactory
remote = RemoteUserMonitor
component = UserMonitor
|
