def __call__(self, *args):
for retry in range(self.max_retries):
try:
return xmlrpclib._Method.__call__(self, *args)
except xmlrpclib.ProtocolError:
err = sys.exc_info()[1]
self.log.error("Server failure: Protocol Error: %s %s" % \
(err.errcode, err.errmsg))
raise xmlrpclib.Fault(20, "Server Failure")
except xmlrpclib.Fault:
raise
except socket.error:
err = sys.exc_info()[1]
if hasattr(err, 'errno') and err.errno == 336265218:
self.log.error("SSL Key error")
break
if hasattr(err, 'errno') and err.errno == 185090050:
self.log.error("SSL CA error")
break
if retry == 3:
self.log.error("Server failure: %s" % err)
raise xmlrpclib.Fault(20, err)
except CertificateError:
ce = sys.exc_info()[1]
self.log.error("Got unallowed commonName %s from server" \
% ce.commonName)
break
except KeyError:
self.log.error("Server disallowed connection")
break
except:
self.log.error("Unknown failure", exc_info=1)
break
time.sleep(0.5)
raise xmlrpclib.Fault(20, "Server Failure")
def RecvProbeData(self, address, probedata):
"""Receive probe data from clients."""
try:
name = self.metadata.resolve_client(address)
meta = self.build_metadata(name)
except Bcfg2.Server.Plugins.Metadata.MetadataConsistencyError:
warning = 'Metadata consistency error'
self.logger.warning(warning)
raise xmlrpclib.Fault(6, warning)
# clear dynamic groups
self.metadata.cgroups[meta.hostname] = []
try:
xpdata = lxml.etree.XML(probedata.encode('utf-8'))
except:
self.logger.error("Failed to parse probe data from client %s" % \
(address[0]))
return False
sources = []
[
sources.append(data.get('source')) for data in xpdata
if data.get('source') not in sources
]
for source in sources:
if source not in self.plugins:
self.logger.warning("Failed to locate plugin %s" % (source))
continue
dl = [data for data in xpdata if data.get('source') == source]
try:
self.plugins[source].ReceiveData(meta, dl)
except:
logger.error("Failed to process probe data from client %s" % \
(address[0]), exc_info=1)
return True
def _marshaled_dispatch(self, address, data):
method_func = None
params, method = xmlrpclib.loads(data)
try:
if '.' not in method:
params = (address, ) + params
response = self.instance._dispatch(method, params, self.funcs)
# py3k compatibility
if type(response) not in [bool, str, list, dict] or response is None:
response = (response.decode('utf-8'), )
else:
response = (response, )
raw_response = xmlrpclib.dumps(response, methodresponse=1,
allow_none=self.allow_none,
encoding=self.encoding)
except xmlrpclib.Fault:
fault = sys.exc_info()[1]
raw_response = xmlrpclib.dumps(fault,
allow_none=self.allow_none,
encoding=self.encoding)
except:
self.logger.error("Unexpected handler error", exc_info=1)
# report exception back to server
raw_response = xmlrpclib.dumps(
xmlrpclib.Fault(1, "%s:%s" % (sys.exc_type, sys.exc_value)),
allow_none=self.allow_none, encoding=self.encoding)
return raw_response
def _dispatch(self, method, args, dispatch_dict):
"""Custom XML-RPC dispatcher for components.
method -- XML-RPC method name
args -- tuple of paramaters to method
"""
need_to_lock = True
if method in dispatch_dict:
method_func = dispatch_dict[method]
else:
try:
method_func = self._resolve_exposed_method(method)
except NoExposedMethod:
self.logger.error("Unknown method %s" % (method))
raise xmlrpclib.Fault(7, "Unknown method %s" % method)
except Exception:
e = sys.exc_info()[1]
if getattr(e, "log", True):
self.logger.error(e, exc_info=True)
raise xmlrpclib.Fault(getattr(e, "fault_code", 1), str(e))
if getattr(method_func, 'locking', False):
need_to_lock = False
if need_to_lock:
lock_start = time.time()
self.lock.acquire()
lock_done = time.time()
try:
method_start = time.time()
try:
result = method_func(*args)
finally:
method_done = time.time()
if need_to_lock:
self.lock.release()
self.instance_statistics.add_value('component_lock',
lock_done - lock_start)
self.instance_statistics.add_value(method, method_done - method_start)
except xmlrpclib.Fault:
raise
except Exception:
e = sys.exc_info()[1]
if getattr(e, "log", True):
self.logger.error(e, exc_info=True)
raise xmlrpclib.Fault(getattr(e, "fault_code", 1), str(e))
return result
def GetConfig(self, address, checksum=False):
"""Build config for a client."""
try:
client = self.metadata.resolve_client(address)
config = self.BuildConfiguration(client)
return lxml.etree.tostring(config, encoding='UTF-8',
xml_declaration=True)
except Bcfg2.Server.Plugins.Metadata.MetadataConsistencyError:
self.logger.warning("Metadata consistency failure for %s" % (address))
raise xmlrpclib.Fault(6, "Metadata consistency failure")
def AssertProfile(self, address, profile):
"""Set profile for a client."""
try:
client = self.metadata.resolve_client(address)
self.metadata.set_profile(client, profile, address)
except (Bcfg2.Server.Plugins.Metadata.MetadataConsistencyError,
Bcfg2.Server.Plugins.Metadata.MetadataRuntimeError):
warning = 'Metadata consistency error'
self.logger.warning(warning)
raise xmlrpclib.Fault(6, warning)
return True
def GetProbes(self, address):
"""Fetch probes for a particular client."""
resp = lxml.etree.Element('probes')
try:
name = self.metadata.resolve_client(address, cleanup_cache=True)
meta = self.build_metadata(name)
for plugin in self.plugins_by_type(Bcfg2.Server.Plugin.Probing):
for probe in plugin.GetProbes(meta):
resp.append(probe)
return lxml.etree.tostring(resp, encoding='UTF-8',
xml_declaration=True)
except Bcfg2.Server.Plugins.Metadata.MetadataConsistencyError:
warning = 'Client metadata resolution error for %s; check server log' % address[0]
self.logger.warning(warning)
raise xmlrpclib.Fault(6, warning)
except Bcfg2.Server.Plugins.Metadata.MetadataRuntimeError:
err_msg = 'Metadata system runtime failure'
self.logger.error(err_msg)
raise xmlrpclib.Fault(6, err_msg)
except:
critical_error("Error determining client probes")
def critical_error(operation):
"""Log and err, traceback and return an xmlrpc fault to client."""
logger.error(operation, exc_info=1)
raise xmlrpclib.Fault(7, "Critical unexpected failure: %s" % (operation))
