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))