#include "AlertService.h"

Inheritance diagram for AlertService:

Collaboration diagram for AlertService:

Public Member Functions
	AlertService (PyServiceMgr *mgr)

virtual	~AlertService ()

Public Member Functions inherited from PyService
	PyService (PyServiceMgr mgr, const char serviceName)

virtual	~PyService ()

virtual PyResult	Call (const std::string &method, PyCallArgs &args)

const char *	GetName () const

Public Member Functions inherited from PyCallable
	PyCallable ()

virtual	~PyCallable ()

Protected Member Functions
PyResult	Handle_BeanCount (PyCallArgs &call)

PyResult	Handle_BeanDelivery (PyCallArgs &call)

PyResult	Handle_GroupBeanDelivery (PyCallArgs &call)

PyResult	Handle_SendClientStackTraceAlert (PyCallArgs &call)
	The client sends us a python stack trace, from which we could make up what we did wrong. More...

Protected Member Functions inherited from PyService
PyObject *	_BuildCachedReturn (PySubStream *result, const char sessionInfo, CacheCheckTime check)

virtual PyBoundObject *	CreateBoundObject (Client pClient, const PyRep bind_args)

virtual PyResult	Handle_MachoResolveObject (PyCallArgs &call)

virtual PyResult	Handle_MachoBindObject (PyCallArgs &call)

Protected Member Functions inherited from PyCallable
void	_SetCallDispatcher (CallDispatcher *d)

Protected Attributes
Dispatcher *const	m_dispatch

PyTraceLog *	traceLogger

Protected Attributes inherited from PyService
PyServiceMgr *const	m_manager

Additional Inherited Members
Protected Types inherited from PyService
enum	CacheCheckTime { check_Always = 0, check_Never, check_in_year, check_in_6_months, check_in_3_months, check_in_1_month, check_in_1_week, check_in_1_day, check_in_12_hours, check_in_6_hours, check_in_3_hours, check_in_2_hours, check_in_1_hour, check_in_30_minutes, check_in_15_minutes, check_in_5_minutes, check_in_1_minute, check_in_30_seconds, check_in_15_seconds, check_in_5_seconds, check_in_1_second, _checkCount }

Static Protected Attributes inherited from PyService
static const char *const	s_checkTimeStrings [_checkCount]

Detailed Description

Definition at line 33 of file AlertService.h.

Constructor & Destructor Documentation

AlertService::AlertService ( PyServiceMgr * mgr )

AlertService::~AlertService ( )

virtual

Definition at line 50 of file AlertService.cpp.

References m_dispatch, SafeDelete(), and traceLogger.

 {
     delete m_dispatch;
     SafeDelete(traceLogger);
 }

Here is the call graph for this function:

Member Function Documentation

PyResult AlertService::Handle_BeanCount ( PyCallArgs & call )

protected

Basically BeanCount means that a error has occurred in the client python code, and it asks the server how to handle it. : in normal operations we should send back a unique mErrorID to the client, it saves it and sends the stack traces to us through BeanDelivery every 15 minutes. When we are in developer mode we should send back PyNone asking the to send us the stack trace immediately.

Definition at line 62 of file AlertService.cpp.

References _log, PyStatic, sConfig, PyTuple::size(), and PyCallArgs::tuple.

Referenced by PyCallable_Make_InnerDispatcher().

                                                         {
     _log(CLIENT__WARNING, "AlertService::Handle_BeanCount(): size=%u", call.tuple->size() );
     //call.Dump(CLIENT__CALL_DUMP);
 
     PyTuple *result = new PyTuple(2);
 
     // what we are sending back is just a static mErrorID and the command not to do anything with it.
     if (sConfig.debug.BeanCount or sConfig.debug.IsTestServer) {
         result->items[0] = PyStatic.NewNone();
     } else {
         result->items[0] = new PyInt(34135);    //ErrorID
     }
 
     result->items[1] = new PyInt(0);        //loggingMode, 0=local, 1=DB (Capt: This isn't correct at all as it seems..)
 
     return (PyRep*)result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

PyResult AlertService::Handle_BeanDelivery ( PyCallArgs & call )

protected

The client "stacks" up the python "stack" traces and sends them every 15 minutes. : this process is only useful when we supply the client with a valid mErrorID. meaning that we should code a mErrorID tracker for it. To handle these.

Definition at line 85 of file AlertService.cpp.

References _log, PyStatic, PyTuple::size(), and PyCallArgs::tuple.

Referenced by PyCallable_Make_InnerDispatcher().

 {
     _log(CLIENT__WARNING, "AlertService::Handle_BeanDelivery(): size=%u", call.tuple->size() );
     //call.Dump(CLIENT__CALL_DUMP);
     /* Unhandled for now as we have no interest in receiving batched python stack traces
      * nor official style debugging... Just gimme the info dude (see Handle_SendClientStackTraceAlert).
      */
     return PyStatic.NewNone();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

PyResult AlertService::Handle_GroupBeanDelivery ( PyCallArgs & call )

protected

Definition at line 95 of file AlertService.cpp.

References _log, PyStatic, PyTuple::size(), and PyCallArgs::tuple.

Referenced by PyCallable_Make_InnerDispatcher().

 {
     _log(CLIENT__WARNING, "AlertService::Handle_GroupBeanDelivery(): size=%u", call.tuple->size() );
     //call.Dump(CLIENT__CALL_DUMP);
 
     return PyStatic.NewNone();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

PyResult AlertService::Handle_SendClientStackTraceAlert ( PyCallArgs & call )

protected

The client sends us a python stack trace, from which we could make up what we did wrong.

Parameters

[in] call is the python packet that contains the info for this function

Note: I'm sending PyNone back, this is just a wild guess. I don't know its actually required. function is part of a system that allows us to ask the client to send the trace directly, and skip the BeanDelivery system.

Returns: guess it should have PyNone back.

Definition at line 113 of file AlertService.cpp.

References _log, is_log_enabled, PyTraceLog::logTrace(), PyStatic, sConfig, PyTuple::size(), traceLogger, and PyCallArgs::tuple.

Referenced by PyCallable_Make_InnerDispatcher().

                                                                         {
     _log(CLIENT__WARNING, "AlertService::Handle_SendClientStackTraceAlert(): size=%u", call.tuple->size() );
     //call.Dump(CLIENT__CALL_DUMP);
     //  self.stacktraceLogMode[stackID[0]] = sm.ProxySvc('alert').SendClientStackTraceAlert(stackID, stackTrace, mode, nextErrorKeyHash)
 
   if (sConfig.debug.StackTrace or is_log_enabled(CLIENT__STACK_TRACE))
     traceLogger->logTrace(*call.tuple);
 
     return PyStatic.NewNone();
 }