def save(self):
log_debug(3, self.username)
rhnSQL.commit()
try:
self.__save()
except:
rhnSQL.rollback()
# shoot the exception up the chain
raise
else:
rhnSQL.commit()
return 0
def process(self):
log_debug(3)
# Query repository; only after a clients signature has been
# authenticated.
try:
method, params = self._get_method_params()
except rhnFault:
f = sys.exc_info()[1]
log_debug(2, "Fault caught")
response = f.getxml()
self.response(response)
return apache.HTTP_NOT_FOUND
except Exception:
e = sys.exc_info()[1]
rhnSQL.rollback()
# otherwise we do a full stop
Traceback(method, self.req, severity="unhandled")
return apache.HTTP_INTERNAL_SERVER_ERROR
# make the actual function call and return the result
return self.call_function(method, params)
class GetHandler(apacheRequest):
# we require our own init since we depend on a channel
def __init__(self, client_version, req):
apacheRequest.__init__(self, client_version, req)
self.channel = None
def _setup_servers(self):
# Nothing to do here
pass
# get a function reference for the GET request
def method_ref(self, method):
log_debug(3, self.server, method)
# Init the repository
server_id = rhnFlags.get("AUTH_SESSION_TOKEN")['X-RHN-Server-Id']
username = rhnFlags.get("AUTH_SESSION_TOKEN")['X-RHN-Auth-User-Id']
repository = rhnRepository.Repository(self.channel, server_id,
username)
repository.set_qos()
f = repository.get_function(method)
if f is None:
raise UnknownXML("function '%s' invalid; path_info is %s" %
(method, self.req.path_info))
return f
# handle the GET requests
def process(self):
log_debug(3)
# Query repository; only after a clients signature has been
# authenticated.
try:
method, params = self._get_method_params()
except rhnFault, f:
log_debug(2, "Fault caught")
response = f.getxml()
self.response(response)
return apache.HTTP_NOT_FOUND
except Exception, e:
rhnSQL.rollback()
# otherwise we do a full stop
Traceback(method, self.req, severity="unhandled")
return apache.HTTP_INTERNAL_SERVER_ERROR
log_debug(3,"redirect exception caught",re.path)
response = re.path
except rhnFault, f:
response = f.getxml()
except rhnSQL.SQLSchemaError, e:
f = None
if e.errno == 20200:
log_debug(2, "User Group Membership EXCEEDED")
f = rhnFault(43, e.errmsg)
elif e.errno == 20220:
log_debug(2, "Server Group Membership EXCEEDED")
f = rhnFault(44, e.errmsg)
if not f:
log_error("rhnSQL.SQLSchemaError caught", e)
rhnSQL.rollback()
# generate the traceback report
Traceback(method, self.req,
extra = "SQL Error generated: %s" % e,
severity="schema")
return apache.HTTP_INTERNAL_SERVER_ERROR
response = f.getxml()
except rhnSQL.SQLError, e:
log_error("rhnSQL.SQLError caught", e)
rhnSQL.rollback()
Traceback(method, self.req,
extra="SQL Error generated: %s" % e,
severity="schema")
return apache.HTTP_INTERNAL_SERVER_ERROR
except Exception, e:
log_error("Unhandled exception", e)
def call_function(self, method, params):
# short-circuit everything if sending a system-wide message.
if CFG.SEND_MESSAGE_TO_ALL:
# Make sure the applet doesn't see the message
if method == 'applet.poll_status':
return self.response({
'checkin_interval': 3600,
'server_status': 'normal'
})
if method == 'applet.poll_packages':
return self.response({'use_cached_copy': 1})
# Fetch global message being sent to clients if applicable.
msg = open(CFG.MESSAGE_TO_ALL).read()
log_debug(3, "Sending message to all clients: %s" % msg)
# Send the message as a fault.
response = xmlrpclib.Fault(
-1, _("IMPORTANT MESSAGE FOLLOWS:\n%s") % msg)
# and now send everything back
ret = self.response(response)
log_debug(4, "Leave with return value", ret)
return ret
# req: where the response is sent to
log_debug(2, method)
# Now we have the reference, call away
force_rollback = 1
try:
rhnSQL.clear_log_id()
# now get the function reference and call it
func = self.method_ref(method)
response = func(*params)
except (TypeError, ValueError, KeyError, IndexError, UnknownXML):
# report exception back to server
fault = 1
if sys.version_info[0] == 3:
exctype = sys.exc_info()[0]
else:
exctype = sys.exc_type
if exctype == UnknownXML:
fault = -1
e_type, e_value = sys.exc_info()[:2]
response = xmlrpclib.Fault(fault, _(
"While running '%s': caught\n%s : %s\n") % (
method, e_type, e_value))
Traceback(method, self.req,
extra="Response sent back to the caller:\n%s\n" % (
response.faultString,),
severity="notification")
except rhnNotFound:
e = sys.exc_info()[1]
return apache.HTTP_NOT_FOUND
# pkilambi:catch exception if redirect
except redirectException:
re = sys.exc_info()[1]
log_debug(3, "redirect exception caught", re.path)
response = re.path
except rhnFault:
f = sys.exc_info()[1]
response = f.getxml()
except rhnSQL.SQLSchemaError:
e = sys.exc_info()[1]
f = None
if e.errno == 20200:
log_debug(2, "User Group Membership EXCEEDED")
f = rhnFault(43, e.errmsg)
if not f:
log_error("rhnSQL.SQLSchemaError caught", e)
rhnSQL.rollback()
# generate the traceback report
Traceback(method, self.req,
extra="SQL Error generated: %s" % e,
severity="schema")
return apache.HTTP_INTERNAL_SERVER_ERROR
response = f.getxml()
except rhnSQL.SQLError:
e = sys.exc_info()[1]
log_error("rhnSQL.SQLError caught", e)
rhnSQL.rollback()
Traceback(method, self.req,
extra="SQL Error generated: %s" % e,
severity="schema")
return apache.HTTP_INTERNAL_SERVER_ERROR
except Exception:
e = sys.exc_info()[1]
log_error("Unhandled exception", e)
rhnSQL.rollback()
# otherwise we do a full stop
Traceback(method, self.req, severity="unhandled")
return apache.HTTP_INTERNAL_SERVER_ERROR
else:
# if no exception, we don't need to rollback
force_rollback = 0
if force_rollback:
rhnSQL.rollback()
rhnSQL.clear_log_id()
# and now send everything back
ret = self.response(response)
log_debug(4, "Leave with return value", ret)
return ret
# authentication.
if req.method == "GET":
try:
ret = self._req_processor.auth_client()
except rhnFault, f:
return self._req_processor.response(f.getxml())
# be safe rather than sorry
if not ret:
log_error("Got a GET call, but auth_client declined",
req.path_info)
return apache.HTTP_METHOD_NOT_ALLOWED
# Avoid leaving Oracle deadlocks
try:
ret = self._req_processor.process()
rhnSQL.rollback()
except:
if not CFG.SEND_MESSAGE_TO_ALL:
rhnSQL.rollback()
raise
log_debug(4, "Leave with return value", ret)
return ret
def cleanupHandler(self, req):
""" Clean up stuff before we close down the session when we are called
from apacheServer.Cleanup() """
log_debug(2)
# kill all of our child processes (if any)
while 1:
pid = status = -1
try:
def handler(self, req):
""" main Apache handler """
log_debug(2)
ret = apacheSession.handler(self, req)
if ret != apache.OK:
return ret
if not CFG.SEND_MESSAGE_TO_ALL:
# Need to get any string template overrides here, before any app
# code gets executed, as the rhnFault error messages use the
# templates
# If send_message_to_all, we don't have DB connectivity though
h = rhnSQL.prepare("select label, value from rhnTemplateString")
h.execute()
templateStrings = {}
while 1:
row = h.fetchone_dict()
if not row:
break
templateStrings[row['label']] = row['value']
if templateStrings:
rhnFlags.set('templateOverrides', templateStrings)
log_debug(4, "template strings: %s" % templateStrings)
if not CFG.SECRET_KEY:
# Secret key not defined, complain loudly
try:
raise rhnException("Secret key not found!")
except:
rhnTB.Traceback(mail=1, req=req, severity="schema")
req.status = 500
req.send_http_header()
return apache.OK
# Try to authenticate the proxy if it this request passed
# through a proxy.
if self.proxyVersion:
try:
ret = self._req_processor.auth_proxy()
except rhnFault:
f = sys.exc_info()[1]
return self._req_processor.response(f.getxml())
# Decide what to do with the request: try to authenticate the client.
# NOTE: only upon GET requests is there Signature information to
# authenticate. XMLRPC requests DO NOT use signature
# authentication.
if req.method == "GET":
try:
ret = self._req_processor.auth_client()
except rhnFault:
f = sys.exc_info()[1]
return self._req_processor.response(f.getxml())
# be safe rather than sorry
if not ret:
log_error("Got a GET call, but auth_client declined",
req.path_info)
return apache.HTTP_METHOD_NOT_ALLOWED
# Avoid leaving Oracle deadlocks
try:
ret = self._req_processor.process()
rhnSQL.rollback()
except:
if not CFG.SEND_MESSAGE_TO_ALL:
rhnSQL.rollback()
raise
log_debug(4, "Leave with return value", ret)
return ret
def handler(self, req):
""" main Apache handler """
log_debug(2)
ret = apacheSession.handler(self, req)
if ret != apache.OK:
return ret
if not CFG.SEND_MESSAGE_TO_ALL:
# Need to get any string template overrides here, before any app
# code gets executed, as the rhnFault error messages use the
# templates
# If send_message_to_all, we don't have DB connectivity though
h = rhnSQL.prepare("select label, value from rhnTemplateString")
h.execute()
templateStrings = {}
while 1:
row = h.fetchone_dict()
if not row:
break
templateStrings[row['label']] = row['value']
if templateStrings:
rhnFlags.set('templateOverrides', templateStrings)
log_debug(4, "template strings: %s" % templateStrings)
if not CFG.SECRET_KEY:
# Secret key not defined, complain loudly
try:
raise rhnException("Secret key not found!")
except:
rhnTB.Traceback(mail=1, req=req, severity="schema")
req.status = 500
req.send_http_header()
return apache.OK
# Try to authenticate the proxy if it this request passed
# through a proxy.
if self.proxyVersion:
try:
ret = self._req_processor.auth_proxy()
except rhnFault:
f = sys.exc_info()[1]
return self._req_processor.response(f.getxml())
# Decide what to do with the request: try to authenticate the client.
# NOTE: only upon GET requests is there Signature information to
# authenticate. XMLRPC requests DO NOT use signature
# authentication.
if req.method == "GET":
try:
ret = self._req_processor.auth_client()
except rhnFault:
f = sys.exc_info()[1]
return self._req_processor.response(f.getxml())
# be safe rather than sorry
if not ret:
log_error("Got a GET call, but auth_client declined",
req.path_info)
return apache.HTTP_METHOD_NOT_ALLOWED
# Avoid leaving Oracle deadlocks
try:
ret = self._req_processor.process()
rhnSQL.rollback()
except:
if not CFG.SEND_MESSAGE_TO_ALL:
rhnSQL.rollback()
raise
log_debug(4, "Leave with return value", ret)
return ret
