def __init__(self, plugin_name, plugin_domain, read_freq, time_to_reading):
from xmlrpclib import ServerProxy
# The proxy through which we talk to the rrd daemon is the
# same for all plugins, so we just initialize it once and
# share it among them
if PluginControl.__plugin_proxy is None:
PluginControl.__plugin_proxy = ServerProxy(
'http://' + SOCKPATH, transport=UnixStreamTransport()).Plugin
if plugin_domain not in PLUGIN_DOMAINS:
raise ValueError("'plugin_domain' = '{}' not one of '{}'".format(
plugin_domain, ', '.join(PLUGIN_DOMAINS)))
if read_freq not in READ_FREQS:
raise ValueError("'read_freq' = '{}' not one of '{}'".format(
read_freq, ', '.join(READ_FREQS)))
self.__time_to_reading = float(time_to_reading)
if time_to_reading >= READ_FREQS[read_freq] - 1:
raise ValueError("'time_to_reading' too high")
self.__mmap = PluginBackend(plugin_name)
self.__plugin_name = plugin_name
self.__plugin_domain = plugin_domain
self.__read_freq = read_freq
self.__dispatch = getattr(PluginControl.__plugin_proxy, plugin_domain)
def __init__(self, plugin_name, plugin_domain, read_freq, time_to_reading):
from xmlrpclib import ServerProxy
# The proxy through which we talk to the rrd daemon is the
# same for all plugins, so we just initialize it once and
# share it among them
if PluginControl.__plugin_proxy is None:
PluginControl.__plugin_proxy = ServerProxy(
'http://' + SOCKPATH,
transport=UnixStreamTransport()
).Plugin
if plugin_domain not in PLUGIN_DOMAINS:
raise ValueError(
"'plugin_domain' = '{}' not one of '{}'".format(
plugin_domain,
', '.join(PLUGIN_DOMAINS)
)
)
if read_freq not in READ_FREQS:
raise ValueError(
"'read_freq' = '{}' not one of '{}'".format(
read_freq,
', '.join(READ_FREQS)
)
)
self.__time_to_reading = float(time_to_reading)
if time_to_reading >= READ_FREQS[read_freq] - 1:
raise ValueError("'time_to_reading' too high")
self.__mmap = PluginBackend(plugin_name)
self.__plugin_name = plugin_name
self.__plugin_domain = plugin_domain
self.__read_freq = read_freq
self.__dispatch = getattr(PluginControl.__plugin_proxy, plugin_domain)
class PluginControl(object):
__plugin_proxy = None
@staticmethod
def __parse_response(response):
if response['Status'] == 'Success':
return response['Value']
else:
raise PluginControlError(response["ErrorDescription"])
def __init__(self, plugin_name, plugin_domain, read_freq, time_to_reading):
from xmlrpclib import ServerProxy
# The proxy through which we talk to the rrd daemon is the
# same for all plugins, so we just initialize it once and
# share it among them
if PluginControl.__plugin_proxy is None:
PluginControl.__plugin_proxy = ServerProxy(
'http://' + SOCKPATH,
transport=UnixStreamTransport()
).Plugin
if plugin_domain not in PLUGIN_DOMAINS:
raise ValueError(
"'plugin_domain' = '{}' not one of '{}'".format(
plugin_domain,
', '.join(PLUGIN_DOMAINS)
)
)
if read_freq not in READ_FREQS:
raise ValueError(
"'read_freq' = '{}' not one of '{}'".format(
read_freq,
', '.join(READ_FREQS)
)
)
self.__time_to_reading = float(time_to_reading)
if time_to_reading >= READ_FREQS[read_freq] - 1:
raise ValueError("'time_to_reading' too high")
self.__mmap = PluginBackend(plugin_name)
self.__plugin_name = plugin_name
self.__plugin_domain = plugin_domain
self.__read_freq = read_freq
self.__dispatch = getattr(PluginControl.__plugin_proxy, plugin_domain)
def __del__(self):
try:
self.__deregister()
except AttributeError:
pass
def get_path(self):
return PluginControl.__parse_response(
PluginControl.__plugin_proxy.get_path(
{'uid': self.__plugin_name}
)
)
def __register(self):
return PluginControl.__parse_response(
self.__dispatch.register({
'uid': self.__plugin_name,
'info': self.__read_freq,
'protocol': 'V2'
})
)
def __deregister(self):
return PluginControl.__parse_response(
self.__dispatch.deregister({'uid': self.__plugin_name})
)
def full_update(self, datasource_list):
self.__mmap.full_update(datasource_list)
def fast_update(self, datasource_list):
self.__mmap.fast_update(datasource_list)
def wake_up_before_next_reading(self):
"""Block until next rrdd stats reading
Args:
time_to_reading: seconds this function returns
before the next reading from rrdd
The xcp-rrdd daemon reads the files written by registered plugins
in pre-determined time intervals. This function coordinates this
timing with the daemon, and wakes up just before the next such
reading occurs. This way, the plugin can provide freshly collected
data. Note that it is up to the plugin author to choose a value
for 'time_to_reading' that is at least as large the time it takes
for the plugin to collect its data; however, it should also not
be much larger, since this decreases the freshness of the data.
"""
from time import sleep
from socket import error as socket_error
while True:
try:
wait_time = self.__register() - self.__time_to_reading
if wait_time < 0:
wait_time = READ_FREQS[self.__read_freq] - wait_time
sleep(wait_time)
return
except socket_error:
# Log this thing instead of stderr
msg = "Failed to contact xcp-rrdd. Sleeping for 5 seconds.."
print msg
sleep(5.0)
class PluginControl(object):
__plugin_proxy = None
@staticmethod
def __parse_response(response):
if response['Status'] == 'Success':
return response['Value']
else:
raise PluginControlError(response["ErrorDescription"])
def __init__(self, plugin_name, plugin_domain, read_freq, time_to_reading):
from xmlrpclib import ServerProxy
# The proxy through which we talk to the rrd daemon is the
# same for all plugins, so we just initialize it once and
# share it among them
if PluginControl.__plugin_proxy is None:
PluginControl.__plugin_proxy = ServerProxy(
'http://' + SOCKPATH, transport=UnixStreamTransport()).Plugin
if plugin_domain not in PLUGIN_DOMAINS:
raise ValueError("'plugin_domain' = '{}' not one of '{}'".format(
plugin_domain, ', '.join(PLUGIN_DOMAINS)))
if read_freq not in READ_FREQS:
raise ValueError("'read_freq' = '{}' not one of '{}'".format(
read_freq, ', '.join(READ_FREQS)))
self.__time_to_reading = float(time_to_reading)
if time_to_reading >= READ_FREQS[read_freq] - 1:
raise ValueError("'time_to_reading' too high")
self.__mmap = PluginBackend(plugin_name)
self.__plugin_name = plugin_name
self.__plugin_domain = plugin_domain
self.__read_freq = read_freq
self.__dispatch = getattr(PluginControl.__plugin_proxy, plugin_domain)
def __del__(self):
try:
self.__deregister()
except AttributeError:
pass
def get_path(self):
return PluginControl.__parse_response(
PluginControl.__plugin_proxy.get_path({'uid': self.__plugin_name}))
def __register(self):
return PluginControl.__parse_response(
self.__dispatch.register({
'uid': self.__plugin_name,
'info': self.__read_freq,
'protocol': 'V2'
}))
def __deregister(self):
return PluginControl.__parse_response(
self.__dispatch.deregister({'uid': self.__plugin_name}))
def full_update(self, datasource_list):
self.__mmap.full_update(datasource_list)
def fast_update(self, datasource_list):
self.__mmap.fast_update(datasource_list)
def wake_up_before_next_reading(self):
"""Block until next rrdd stats reading
Args:
time_to_reading: seconds this function returns
before the next reading from rrdd
The xcp-rrdd daemon reads the files written by registered plugins
in pre-determined time intervals. This function coordinates this
timing with the daemon, and wakes up just before the next such
reading occurs. This way, the plugin can provide freshly collected
data. Note that it is up to the plugin author to choose a value
for 'time_to_reading' that is at least as large the time it takes
for the plugin to collect its data; however, it should also not
be much larger, since this decreases the freshness of the data.
"""
from time import sleep
from socket import error as socket_error
while True:
try:
wait_time = self.__register() - self.__time_to_reading
if wait_time < 0:
wait_time = READ_FREQS[self.__read_freq] - wait_time
sleep(wait_time)
return
except socket_error:
# Log this thing instead of stderr
msg = "Failed to contact xcp-rrdd. Sleeping for 5 seconds.."
print msg
sleep(5.0)
