Your IP : 172.28.240.42
import logging
import os
from twisted.internet.utils import getProcessOutput
from landscape.package.store import PackageStore
from landscape.package.reporter import find_reporter_command
from landscape.monitor.plugin import MonitorPlugin
class PackageMonitor(MonitorPlugin):
run_interval = 1800
scope = "package"
def __init__(self, package_store_filename=None):
super(PackageMonitor, self).__init__()
if package_store_filename:
self._package_store = PackageStore(package_store_filename)
else:
self._package_store = None
self._reporter_command = find_reporter_command()
def register(self, registry):
self.config = registry.config
self.run_interval = self.config.package_monitor_interval
if self.config.clones and self.config.is_clone:
# Run clones a bit more frequently in order to catch up
self.run_interval = 60 # 300
super(PackageMonitor, self).register(registry)
if not self._package_store:
filename = os.path.join(registry.config.data_path,
"package/database")
self._package_store = PackageStore(filename)
registry.register_message("package-ids",
self._enqueue_message_as_reporter_task)
registry.reactor.call_on("server-uuid-changed",
self._server_uuid_changed)
self.call_on_accepted("packages", self.spawn_reporter)
self.run()
def _enqueue_message_as_reporter_task(self, message):
self._package_store.add_task("reporter", message)
self.spawn_reporter()
def run(self):
result = self.registry.broker.get_accepted_message_types()
result.addCallback(self._got_message_types)
return result
def _got_message_types(self, message_types):
if "packages" in message_types:
self.spawn_reporter()
def _run_fake_reporter(self, args):
"""Run a fake-reporter in-process."""
class FakeFacade(object):
"""
A fake facade to workaround the issue that the AptFacade
essentially allows only once instance per process.
"""
def get_arch(self):
arch = os.uname()[-1]
result = {"pentium": "i386",
"i86pc": "i386",
"x86_64": "amd64"}.get(arch)
if result:
arch = result
elif (arch[0] == "i" and arch.endswith("86")):
arch = "i386"
return arch
if getattr(self, "_fake_reporter", None) is None:
from landscape.package.reporter import (
FakeReporter, PackageReporterConfiguration)
from landscape.package.store import FakePackageStore
package_facade = FakeFacade()
package_config = PackageReporterConfiguration()
package_config.load(args + ["-d", self.config.data_path,
"-l", self.config.log_dir])
package_store = FakePackageStore(package_config.store_filename)
self._fake_reporter = FakeReporter(package_store, package_facade,
self.registry.broker,
package_config)
self._fake_reporter.global_store_filename = os.path.join(
self.config.master_data_path, "package", "database")
self._fake_reporter_running = False
if self._fake_reporter_running:
from twisted.internet.defer import succeed
return succeed(None)
self._fake_reporter_running = True
result = self._fake_reporter.run()
def done(passthrough):
self._fake_reporter_running = False
return passthrough
return result.addBoth(done)
def spawn_reporter(self):
args = ["--quiet"]
if self.config.config:
args.extend(["-c", self.config.config])
env = os.environ.copy()
if self.config.clones > 0:
if self.config.is_clone:
return self._run_fake_reporter(args)
else:
env["FAKE_GLOBAL_PACKAGE_STORE"] = "1"
# path is set to None so that getProcessOutput does not
# chdir to "." see bug #211373
result = getProcessOutput(self._reporter_command,
args=args, env=env,
errortoo=1,
path=None)
result.addCallback(self._got_reporter_output)
return result
def _got_reporter_output(self, output):
if output:
logging.warning("Package reporter output:\n%s" % output)
def _reset(self):
"""
Remove all tasks *except* the resynchronize task. This is
because if we clear all tasks, then add the resynchronize,
it's possible that the reporter may be running a task at this
time and when it finishes, it will unknowningly remove the
resynchronize task because sqlite resets its serial primary
keys when you delete an entire table. This problem is avoided
by adding the task first and removing them all *except* the
resynchronize task and not causing sqlite to reset the serial
key.
"""
task = self._package_store.add_task("reporter",
{"type": "resynchronize"})
self._package_store.clear_tasks(except_tasks=(task,))
def _server_uuid_changed(self, old_uuid, new_uuid):
"""Called when the broker sends a server-uuid-changed event.
The package hash=>id map is server-specific, so when we change
servers, we should reset this map.
"""
# If the old_uuid is None, it means we're just starting to
# communicate with a server that knows how to report its UUID,
# so we don't clear our knowledge.
if old_uuid is not None:
self._package_store.clear_hash_ids()