PyConnectStub.cpp

/*
 *  PyConnectStub.cpp
 *  
 *  Copyright 2006, 2007 Xun Wang.
 *  This file is part of PyConnect.
 *
 *  PyConnect is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  PyConnect is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifdef WIN32
#pragma warning( disable: 4018 )
#include <ws2tcpip.h>
#else
#include <arpa/inet.h>
#endif

#include <cstring>
#include "PyConnectStub.h"

namespace pyconnect {

#if PY_MAJOR_VERSION >= 3
  #define PyInt_FromLong PyLong_FromLong
  #define PyInt_AsLong PyLong_AsLong
  #define PyInt_Check PyLong_Check
#endif

// static variables
PyDoc_STRVAR( PyConnectObject_doc, "PyConnect Object. Not documented." );
PyDoc_STRVAR( PyConnect_doc, \
              "PyConnect module is a module that act as an central interface to all available Pythonised OPEN-R objects." );
static PyTypeObject PyConnectObjectType = {
  PyVarObject_HEAD_INIT(&PyType_Type, 0)
  "PyConnect.PyConnectObject",  /* tp_name */
  sizeof(PyConnectObject),  /* tp_basicsize */
  0,            /* tp_itemsize */
  (destructor)PyConnectObject::dealloc,  /* tp_dealloc */
  0,            /*tp_print*/
  0,            /*tp_getattr*/
  0,            /*tp_setattr*/
  0,            /*tp_reserved*/
  0,            /*tp_repr*/
  0,            /*tp_as_number*/
  0,            /*tp_as_sequence*/
  0,            /*tp_as_mapping*/
  0,            /*tp_hash */
  0,            /*tp_call*/
  0,            /*tp_str*/
  PyConnectObject::getAttr,  /*tp_getattro*/
  PyConnectObject::setAttr,  /*tp_setattro*/
  0,            /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,    /*tp_flags*/
  PyConnectObject_doc,    /* tp_doc */
  0,            /* tp_traverse */
  0,            /* tp_clear */
  0,            /* tp_richcompare */
  0,            /* tp_weaklistoffset */
  0,            /* tp_iter */
  0,            /* tp_iternext */
  0,            /* tp_methods */
  0,            /* tp_members */
  0,            /* tp_getset */
  &PyBaseObject_Type,            /* tp_base */
  0,            /* tp_dict */
  0,            /* tp_descr_get */
  0,            /* tp_descr_set */
  0,            /* tp_dictoffset */
  (initproc)PyConnectObject::pyInit,  /* tp_init */
  0,            /* tp_alloc */
  PyConnectObject::pyNew    /* tp_new */
};

static PyTypeObject PyConnectMethodType = {
  PyVarObject_HEAD_INIT(NULL, 0)
  "PyConnect.PyConnectMethod",     /*tp_name*/
  sizeof(PyConnectMethod),      /*tp_basicsize*/
  0,                         /*tp_itemsize*/
  (destructor)PyConnectMethod::dealloc, /*tp_dealloc*/
  0,                        /*tp_print*/
  0,                        /*tp_getattr*/
  0,                        /*tp_setattr*/
  0,                        /*tp_compare*/
  0,                        /*tp_repr*/
  0,                        /*tp_as_number*/
  0,                        /*tp_as_sequence*/
  0,                        /*tp_as_mapping*/
  0,                        /*tp_hash */
  0,                        /*tp_call*/
  0,                        /*tp_str*/
  0,                        /*tp_getattro*/
  0,                        /*tp_setattro*/
  0,                        /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT,       /*tp_flags*/
  "PyConnectMethod objects",   /* tp_doc */
  0,                        /* tp_traverse */
  0,                        /* tp_clear */
  0,                        /* tp_richcompare */
  0,                        /* tp_weaklistoffset */
  0,                        /* tp_iter */
  0,                        /* tp_iternext */
  0,                        /* tp_methods */
  0,                        /* tp_members */
  0,                        /* tp_getset */
  0,                        /* tp_base */
  0,                        /* tp_dict */
  0,                        /* tp_descr_get */
  0,                        /* tp_descr_set */
  0,                        /* tp_dictoffset */
  0,                        /* tp_init */
  0,                        /* tp_alloc */
  0,                        /* tp_new */
};
/**
*  Static method to initiate PyConnect extension module
 *
 */
static PyMethodDef PyConnect_methods[] = {
  { "write", PyConnectStub::PyConnect_write, METH_VARARGS,
    "standard output for PyConnect server console" },
  { "discover", (PyCFunction)PyConnectStub::PyConnect_discover, METH_NOARGS,
    "search for available PyConnect objects" },
  { "connect", (PyCFunction)PyConnectStub::PyConnect_connect, METH_VARARGS,
    "connect to a specific remote PyConnect component" },
  { "disconnect", (PyCFunction)PyConnectStub::PyConnect_disconnect, METH_VARARGS,
    "disconnect a specific remote PyConnect component" },
  { "set_broadcast", (PyCFunction)PyConnectStub::PyConnect_set_broadcast, METH_VARARGS,
    "set new broadcast address" },
  { "send_peer_message", (PyCFunction)PyConnectStub::PyConnect_send_peer_msg, METH_VARARGS,
    "send peer servers a message" },
  { NULL, NULL, 0, NULL }           /* sentinel */
};

PyConnectArgument::PyConnectArgument( std::string & name, PyConnectType::Type type,
                               bool optional ) :
  name_( name ),
  type_( type ),
  isOptional_( optional )
{}

PyConnectArgument::PyConnectArgument( PyConnectType::Type type, bool optional ) :
  name_( "" ),
  type_ ( type ),
  isOptional_( optional )
{}

PyConnectAttribute::PyConnectAttribute( std::string & name, PyConnectType::Type type,
  bool readonly, PyObject * initValue ) :
  PyConnectArgument( name, type ),
  readonly_( readonly ),
  value_( initValue )  // we steal reference
{}

PyConnectAttribute::~PyConnectAttribute()
{
  Py_DECREF( value_ );
}

void PyConnectAttribute::setValue( PyObject * newValue )
{
  // assume we get a value with new reference
  Py_DECREF( value_ );
  value_ = newValue;
}

PyConnectObject::PyConnectObject() :
  noCallback_( false ),
  argEvalReversed_( false )
{
  PyConnectObject( "Generic PyConnect object", -1, 
    "Undocumented PyConnect object" );
}

PyConnectObject::PyConnectObject( const char * name, int id, const char * desc, char options ) :
  noCallback_( false ),
  argEvalReversed_( false )
{
  PyObject_INIT( this, &PyConnectObjectType );

  if (name)
    this->name_ = std::string( name );
  else
    this->name_ = std::string( "Generic PyConnect object" );

  if (desc) {
    this->desc_ = std::string( desc );
  }
  else {
    this->desc_ = "Undocumented PyConnect object";
  }
  this->id_ = id;
  
  if (options == 1) {
    argEvalReversed_ = true;
  }

  this->myDict_ = PyDict_New();
  PyObject * idObj = PyInt_FromLong( id );
  PyDict_SetItemString( this->myDict_, "id", idObj );
  Py_DECREF( idObj );
#if PY_MAJOR_VERSION >= 3
  PyObject * nameObj = PyUnicode_FromString( name );
#else
  PyObject * nameObj = PyString_FromString( name );
#endif
  PyDict_SetItemString( this->myDict_, "__name__", nameObj );
  Py_DECREF( nameObj );
}

void PyConnectObject::init( char * name, int id, char * desc )
{
  if (name)
    this->name_ = std::string( name );

  if (desc) {
    this->desc_ = std::string( desc );
  }

  this->id_ = id;
  PyObject * idObj = PyInt_FromLong( id );
  PyDict_SetItemString( this->myDict_, "id", idObj );
  Py_DECREF( idObj );
#if PY_MAJOR_VERSION >= 3
  PyObject * nameObj = PyUnicode_FromString( name );
#else
  PyObject * nameObj = PyString_FromString( name );
#endif
  PyDict_SetItemString( this->myDict_, "__name__", nameObj );
  Py_DECREF( nameObj );
}

void PyConnectObject::setNetworkAddress( struct sockaddr_in & cAddr )
{
  if (cAddr.sin_family != AF_INET)
    return;
    
  PyObject * portObj = PyInt_FromLong( cAddr.sin_port );
  PyDict_SetItemString( this->myDict_, "__port__", portObj );
  Py_DECREF( portObj );
  
  char cAddrStr[INET_ADDRSTRLEN];
  inet_ntop( AF_INET, &cAddr.sin_addr.s_addr, cAddrStr, INET_ADDRSTRLEN );

#if PY_MAJOR_VERSION >= 3
  PyObject * ipObj = PyUnicode_FromString( cAddrStr );
#else
  PyObject * ipObj = PyString_FromString( cAddrStr );
#endif

  PyDict_SetItemString( this->myDict_, "__ip__", ipObj );
  Py_DECREF( ipObj );
}

PyConnectObject::~PyConnectObject()
{
  for (pyAttributes::iterator iter = pPyAttrs_.begin();
     iter != pPyAttrs_.end(); iter++)
  {
    delete *iter;
  }
  pPyAttrs_.clear();
  
  for (pyMethods::iterator iter = pPyMetds_.begin();
     iter != pPyMetds_.end(); iter++)
  {
    delete *iter;
  }
  pPyMetds_.clear();
  PyDict_Clear( this->myDict_ );
  Py_XDECREF( this->myDict_ );
}

PyObject * PyConnectObject::pyNew( PyTypeObject * type, PyObject * args,
    PyObject * kwds )
{
  // NOTE: this pyNew should only be called on the server side
  // PyConnectObject created this way does not correspond to actual 
  // Pythonised OPEN-R object by itself (Implication for this is 
  // that it does not have an ID and not in  the internal live 
  // PyConnect object list.
  //DEBUG_MSG( "PyConnectObject::pyNew\n" );
  static const char *kwlist[] = { "name", "id", "doc", NULL };

  PyObject * py_name = NULL;
  PyObject * py_doc = NULL;
  int id = 0;

  if (!PyArg_ParseTupleAndKeywords( args, kwds, "O|iO", (char **)kwlist, 
    &py_name, &id, &py_doc ))
  {
    return NULL;
  }
#if PY_MAJOR_VERSION >= 3
  PyObject * unicodeobj1 = PyUnicode_FromObject( py_name );
  PyObject * unicodeobj2 = NULL;
  char * namestr = PyUnicode_AsUTF8( unicodeobj1 );
  char * docstr = NULL;
  if (py_doc) {
    unicodeobj2 = PyUnicode_FromObject( py_doc );
    docstr = PyUnicode_AsUTF8( unicodeobj2 );
  }
  Py_DECREF( unicodeobj1 );
  PyObject * connobj = (PyObject *) new PyConnectObject( namestr, id, docstr );
  if (unicodeobj2) {
    Py_DECREF( unicodeobj2 );
  }
  return connobj;
#else
  return (PyObject *) new PyConnectObject( PyString_AS_STRING( py_name ),
    id, py_doc ? PyString_AS_STRING( py_doc ) : NULL );
#endif
}

int PyConnectObject::pyInit( PyConnectObject * self, PyObject * args,
    PyObject * kwds )
{
  return 0;
}

void PyConnectObject::addNewAttribute( std::string & name,
    PyConnectType::Type type, bool readOnly, PyObject * initValue )
{
  INFO_MSG( "PyConnectObject:: add new %s attribute: %s, type %d\n",
         readOnly ? "readonly" : "", name.c_str(), (int)type );
  pPyAttrs_.push_back( new PyConnectAttribute( name, type, readOnly, initValue ) );
  PyDict_SetItemString( this->myDict_, name.c_str(), initValue );
}

void PyConnectObject::addNewMethod( std::string & metdName, 
    PyConnectType::Type type, pyArguments & args, int optArgs )
{
  INFO_MSG( "PyConnectObject:: add a new method: %s rettype %d "
    "args %d, optional args %d\n", metdName.c_str(), (int)type,
    (int)args.size(), optArgs );
  INFO_MSG( "Arguments are:\n" );
  for (unsigned int i=0; i<args.size(); i++) {
    INFO_MSG( "\ttype %d\n", (int) args[i]->type() );
  }
  PyConnectMethod * pMetd = new PyConnectMethod( this, metdName, type, args, optArgs );
  pPyMetds_.push_back( pMetd );
  PyDict_SetItemString( this->myDict_, metdName.c_str(), pMetd );
}

PyObject * PyConnectObject::getAttribute( char * name )
{
  if (!strcmp( name, "__doc__" )) {
#if PY_MAJOR_VERSION >= 3
    return PyUnicode_FromString( this->desc_.c_str() );
#else
    return PyString_FromString( this->desc_.c_str() );
#endif
  }

  if (!strcmp( name, "__nocallback__" )) {
    if (this->noCallback_)
      Py_RETURN_TRUE;
    else
      Py_RETURN_FALSE;
  }

  if (!strcmp( name, "__dict__" )) {
    Py_INCREF( this->myDict_ );
    return this->myDict_;
  }
  bool found = false;
  pyAttributes::iterator aiter;
  for (aiter = pPyAttrs_.begin();aiter != pPyAttrs_.end();aiter++) {
    if (!strcmp( name, (*aiter)->name().c_str() )) {
      found = true;
      break;
    }
  }

  if (found) {
    return (*aiter)->getValue();
  }
  pyMethods::iterator miter;
  for (miter = pPyMetds_.begin();miter != pPyMetds_.end();miter++) {
    if (!strcmp( name, (*miter)->name().c_str() )) {
      found = true;
      break;
    }
  }
  if (found) {
    PyObject * metdObj = (*miter)->methodObj();
    if (!PyCallable_Check( metdObj )) {
      PyErr_Format( PyExc_TypeError, "%s is not callable object", name );
      return NULL;
    }
    else {
      return metdObj;
    }
  }
  // check dictionary
  PyObject * otherAttr = PyDict_GetItemString( this->myDict_, name );
  if (otherAttr) {
    Py_INCREF( otherAttr );
    return otherAttr;
  }
  else { // let python generic get attribute have a go
#if PY_MAJOR_VERSION >= 3
    PyObject * pName = PyUnicode_FromString( name );
#else
    PyObject * pName = PyString_FromString( name );
#endif
    PyObject * pResult = PyObject_GenericGetAttr( this, pName );
    Py_DECREF( pName );
    return pResult;
  }
}

int PyConnectObject::setAttribute( char * name, PyObject * value )
{
  if (!value)
    return -1;
  
  std::string attName( name );

  if (!strcmp( name, "__nocallback__" )) {
    if (PyBool_Check( value )) {
      this->noCallback_ = (value == Py_True);
    }
    else {
      PyErr_Format( PyExc_AttributeError, 
        "%s must take a boolean value.", name );
      return -1;
    }
  }

  // check buildin readonly attributes
  if (!strcmp( name, "__name__" ) ||
      !strcmp( name, "id" ) )
  {
    PyErr_Format( PyExc_AttributeError, 
      "%s is a read-only build-in attribute.", name );
    return -1;
  }
  if (!strcmp( name, "__doc__" )) {
#if PY_MAJOR_VERSION >= 3
    PyObject * unicodeobj = PyUnicode_FromObject( value );
    this->desc_ = std::string( PyUnicode_AsUTF8( unicodeobj ) );
    Py_DECREF( unicodeobj );
#else
    this->desc_ = std::string( PyString_AsString( value ) );
#endif
    return 0;
  }

  bool found = false;
  pyAttributes::iterator aiter;
  for (aiter = pPyAttrs_.begin();aiter != pPyAttrs_.end();aiter++) {
    if (attName == (*aiter)->name()) {
      found = true;
      break;
    }
  }
  
  if (found) {
    if ((*aiter)->isReadOnly()) {
      PyErr_Format( PyExc_AttributeError, "attribute %s is read-only.", name );
      return -1;
    }
    int aind = int(aiter - pPyAttrs_.begin());
    int valSize = PyConnectType::validateTypeAndSize( value, (*aiter)->type() );
    if (!valSize ) {
      PyErr_Format( PyExc_ValueError, "value for attribute %s is not a %s",
        (*aiter)->name().c_str(), PyConnectType::typeName( (*aiter)->type() ).c_str() );
      return -1;
    }
    unsigned char * valBuf = new unsigned char[valSize];
    unsigned char * dataPtr = valBuf;
    PyConnectType::packToStr( value, (*aiter)->type(), dataPtr );
    if (this->noCallback_) {
      Py_INCREF( value );
      (*aiter)->setValue( value );
      PyConnectStub::instance()->remoteAttrMethodCall( this, aind, valBuf, valSize, CALL_ATTR_METD_NOCB );
    }
    else {
      PyConnectStub::instance()->remoteAttrMethodCall( this, aind, valBuf, valSize );
    }
    delete [] valBuf;
    return 0;
  }
  pyMethods::iterator miter;
  for (miter = pPyMetds_.begin();miter != pPyMetds_.end();miter++) {
    if (!strcmp( name, (*miter)->name().c_str() )) {
      found = true;
      break;
    }
  }
  if (found) {
    PyErr_Format( PyExc_TypeError, "%s is a built-in method provided by "
      "%s PyConnect Object. You cannot override it!", name, this->name_.c_str() );
    return -1;
  }
  // check our dictionary
  PyObject * otherAttr = PyDict_GetItemString( this->myDict_, name );
  if (otherAttr) {
    if (value == Py_None) // delete
      PyDict_DelItemString( this->myDict_, name );
    else
      PyDict_SetItemString( this->myDict_, name, value );
  }
  else {
    PyDict_SetItemString( this->myDict_, name, value );
  }
  return 0;
}

void PyConnectObject::onSetAttrMetdResp( int index, int err, unsigned char * & data, int & remainingLength )
{
  std::string fname;
  PyObject * arg = NULL;

  if (index < (int)pPyAttrs_.size()) {
    pyAttributes::iterator aiter = pPyAttrs_.begin() + index;
    fname = (*aiter)->name();
    if (err) {  // onSetAttFailed
      fname = "onSet" + fname + "Failed";
      arg = Py_BuildValue( "(i)", err );
    }
    else {  //onSetAtt
      fname = "onSet" + fname;
      PyObject * retVal = 
        PyConnectType::unpackStr( (*aiter)->type(), data, remainingLength );
      (*aiter)->setValue( retVal );
      arg = Py_BuildValue( "(O)", retVal );
    }
  }
  else {
    int mindex = index - (int)pPyAttrs_.size();
    if (mindex < (int)pPyMetds_.size()) {
      pyMethods::iterator miter = pPyMetds_.begin() + mindex;
      fname = (*miter)->name();
      if (err) {  // onMetdFailed
        fname = "on" + fname + "Failed";
        arg = Py_BuildValue( "(i)", err );
      }
      else {  //onMetdComplete
        fname = "on" + fname + "Completed";
        PyObject * retVal =
          PyConnectType::unpackStr( (*miter)->retType(), data, remainingLength );
        arg = Py_BuildValue( "(O)", retVal );
        Py_DECREF( retVal );
      }
    }
    else {
      fname = "onUnknownAttrMetdError";
      arg = Py_BuildValue( "(i)", index );
    }
  }
  PyConnectStub::invokeCallback( this, fname.c_str(), arg );
  Py_DECREF( arg );
}

void PyConnectObject::onGetAttrResp( int index, int err, unsigned char * & data, int & remainingLength )
{
  std::string fname;
  PyObject * arg = NULL;
  
  //DEBUG_MSG( "onGetAttrResp, id %d, err %d, len %d, data %.*s\n", index, err, remainingLength,
  //           remainingLength, data );
  
  if (index < (int)pPyAttrs_.size()) {
    pyAttributes::iterator aiter = pPyAttrs_.begin() + index;
    fname = (*aiter)->name();
    if (err) {  // onAttrUpdateFailed
      fname = "on" + fname + "UpdateFailed";
      arg = Py_BuildValue( "(i)", err );
    }
    else {  //onAttrUpdate
      fname = "on" + fname + "Update";
      PyObject * retVal = 
        PyConnectType::unpackStr( (*aiter)->type(), data, remainingLength );
      (*aiter)->setValue( retVal );
      arg = Py_BuildValue( "(O)", retVal );
    }
  }
  else {
    fname = "onUnknownAttrbuteError";
    arg = Py_BuildValue( "(i)", index );
  }
  PyConnectStub::invokeCallback( this, fname.c_str(), arg );
  Py_DECREF( arg );
}

void PyConnectObject::onSetAttrMetdDesc( unsigned char * & data, int & remainingLength )
{
    /* let's hope our message is not corrupted hahaha */
  int nofattrs = unpackStrToInt( data, remainingLength );
  for (int i = 0;i < nofattrs;i++) {
    pPyAttrs_[i]->setDescription( unpackString( data, remainingLength, true ) );
  }

  // unpacking methods
  int nofmetds = unpackStrToInt( data, remainingLength );
  for (int i = 0;i < nofmetds;i++) {
    pPyMetds_[i]->setDescription( unpackString( data, remainingLength, true ) );
  }
}

/*
 *====================
 * PyConnectStub section
 *====================
 */

PyConnectStub * PyConnectStub::s_pPyConnectStub = NULL;

PyConnectStub::PyConnectStub( PyOutputWriter * pow, PyObject * pyConnect ) :
  pow_( pow ),
  pPyConnect_( pyConnect ),
  nextObjId_( 1 ),
  serverID_( PYCONNECT_DEFAULT_SERVER_ID )
{
}

PyConnectStub::~PyConnectStub()
{
  unsigned char dataBuffer[3];

  for (PyModules::const_iterator miter = modules_.begin();
       miter != modules_.end(); miter++)
  {
    dataBuffer[0] = (unsigned char) (SERVER_SHUTDOWN << 4 | (this->serverID_ & 0xf));
    dataBuffer[1] = (unsigned char) (*miter)->id();
    dataBuffer[2] = PYCONNECT_MSG_END;
    this->dispatchMessage( dataBuffer, 3 );
    Py_DECREF( *miter );
  }
  modules_.clear();
  Py_DECREF( pPyConnect_ );
}

void PyConnectStub::remoteAttrMethodCall( PyConnectObject * pObject, int index,
  unsigned char * argStr, int argLen, PyConnectMsg msgType )
{
  int objID = pObject->id();
  if (objID < 0)
    return;

  int asl = packedIntLen( index );
  int totalMsgSize = 3 + sizeof( int ) + asl + argLen;
  unsigned char * dataBuffer = new unsigned char[totalMsgSize];
  
  unsigned char * bufPtr = dataBuffer;
  
  *bufPtr = (unsigned char) (msgType << 4 | (this->serverID_ & 0xf)); bufPtr++;
  *bufPtr = (unsigned char) objID; bufPtr++;
  int dataLength = asl + argLen;
  packToLENumber( dataLength, bufPtr );

  packIntToStr( index, bufPtr );
  if (!(argLen == 0 || argStr == NULL)) {
    memcpy( bufPtr, argStr, argLen );
    bufPtr += argLen;
  }
  *bufPtr = PYCONNECT_MSG_END;
  this->dispatchMessage( dataBuffer, totalMsgSize );
  delete [] dataBuffer;
}

void PyConnectStub::assignModuleID( std::string & name, int id )
{
  int totalMsgSize = 4 + (int)name.length();
  unsigned char * dataBuffer = new unsigned char[totalMsgSize];
  
  unsigned char * bufPtr = dataBuffer;
  
  *bufPtr = (unsigned char) (MODULE_ASSIGN_ID << 4 | (this->serverID_ & 0xf)); bufPtr++;
  *bufPtr = (unsigned char) id; bufPtr++;
  packString( (unsigned char*)name.data(), (int)name.length(), bufPtr );
  *bufPtr = PYCONNECT_MSG_END;

  this->dispatchMessage( dataBuffer, totalMsgSize );
  delete [] dataBuffer;
}

PyConnectStub * PyConnectStub::init( PyOutputWriter * pow )
{
  if (!s_pPyConnectStub) {
    assert( PyType_Ready(&PyConnectObjectType) >= 0 );
    assert( PyType_Ready(&PyConnectMethodType) >= 0 );

#if PY_MAJOR_VERSION >= 3
    PyModuleDef * def = new PyModuleDef();
    std::memset( def, 0, sizeof( PyModuleDef ) );
    def->m_name = "PyConnect";
    def->m_doc = PyConnect_doc;
    def->m_size = -1;
    def->m_methods = PyConnect_methods;
    Py_INCREF( def );
    PyObject * pyConnect = PyModule_Create( def );
#else
    PyObject * pyConnect = 
      Py_InitModule3( "PyConnect", PyConnect_methods, PyConnect_doc );
#endif


    Py_INCREF( &PyConnectObjectType );
    Py_INCREF( &PyConnectMethodType );

    //PyModule_AddObject( pyConnect, "PyConnectObject", (PyObject *)&PyConnectObjectType );

    s_pPyConnectStub = new PyConnectStub( pow, pyConnect );
  }
  return s_pPyConnectStub;
}

void PyConnectStub::fini()
{
  if (!s_pPyConnectStub) {
    delete s_pPyConnectStub;
    s_pPyConnectStub = NULL;
  }
}

void PyConnectStub::updateMPID( int id )
{
  if (serverID_ != PYCONNECT_DEFAULT_SERVER_ID) { // this means the server id has been set before
    WARNING_MSG( "PythonServer: server ID is being changed from %d to %d\n",
                serverID_, id );
  }
  serverID_ = id;
  PyObject * idObj = PyInt_FromLong( id );
  PyObject_SetAttrString( pPyConnect_, "ServerID", idObj );
  Py_DECREF( idObj );
}

void PyConnectStub::addNewModule( std::string & name, std::string & desc, char options, struct sockaddr_in & cAddr )
{
  INFO_MSG( "Creating new PyConnectObject: %s\n", name.c_str() );

  if (name == "") {
    ERROR_MSG( "PyConnectStub::addNewModule: Module name is empty.\n" );
    return;
  }
  if (nextObjId_ > 0xff) {
    ERROR_MSG( "PyConnectStub::addNewModule: maximum number registered "
           "module reached Ignore.\n" );
    return;
  }

  // threadsafe lock
  PyGILState_STATE gstate;
  gstate = PyGILState_Ensure();
  
  // trying to load a module script contains partial implementation
  // for the PyConnect module
/* Not use this for the moment.
#ifdef DOS_FILENAME_LENGTH
  std::string filename = name.substr( 0, 8 );
  INFO_MSG( "Attempt to import corresponding %s script%s\n", filename.c_str(),
    name.length() > 8 ? "[Name truncated]" : "" );
#else
  std::string filename = name;
  INFO_MSG( "Attempt to import corresponding %s script\n", filename.c_str() );
#endif

  PyObject * pModule = PyImport_ImportModule( const_cast<char *>(filename.c_str()) );
  PyObject * pClass = NULL;
*/
  PyConnectObject * py_newObj = NULL;
/*
  if (pModule == NULL) {
    if (PyErr_Occurred() == PyExc_ImportError) {
      ERROR_MSG( "Error importing %s script\n", filename.c_str() );
      PyErr_Print();
    }
    PyErr_Clear();
  }
  else {
    pClass = PyObject_GetAttrString( pModule, const_cast<char*>(name.c_str()) );
  }

  if (pClass) {
    // check if the imported class is a sub class of PyConnectObject
    if (PyObject_TypeCheck( pClass, &PyConnectObjectType )) { 

      //py_newObj = static_cast<PyConnectObject *>(_PyObject_New( (PyTypeObject *)pClass ));
      if (!py_newObj) {
        ERROR_MSG( "Unable to create new type object\n" );
      }
      else {
        py_newObj->init( name.c_str(), nextObjId_, 
          (desc != "" ? desc.c_str() : NULL) );
      }
    }
    else {
      ERROR_MSG( "PyConnectStub::addNewModule: Imported class %s is not a "
                 "sub type of PyConnectObject. Ignore.\n", name.c_str() );
    }
  }
  else {
    // clear only earlier errors
    PyErr_Clear(); 
    */
    py_newObj = new PyConnectObject( name.c_str(), nextObjId_, 
                                  (desc != "" ? desc.c_str() : NULL), options );
//  }
//  Py_XDECREF( pClass );
//  Py_XDECREF( pModule );

  assert( py_newObj != NULL );
  py_newObj->setNetworkAddress( cAddr );
  PyObject_SetAttrString( pPyConnect_, const_cast<char*>(name.c_str()), py_newObj );
  
  modules_.push_back( py_newObj );
  PyGILState_Release( gstate );

  assignModuleID( name, nextObjId_++ );
}

PyConnectObject * PyConnectStub::findModuleByID( int id )
{
  PyModules::iterator miter = modules_.begin();
  
  while (!(miter==modules_.end() || (*miter)->id() == id)) miter++;
  
  if (miter == modules_.end())
    return NULL;
  else
    return *miter;
}

void PyConnectStub::shutdownModuleByRef( PyConnectObject * obj )
{
  //DEBUG_MSG( "PyConnectStub::deleteModuleByID %d\n", id );
  PyModules::iterator miter = modules_.begin();
  
  while (!(miter == modules_.end() || (*miter) == obj)) miter++;
  
  if (miter != modules_.end()) {
    unsigned char dataBuffer[3];
    
    dataBuffer[0] = (unsigned char) (SERVER_SHUTDOWN << 4 | (this->serverID_ & 0xf));
    dataBuffer[1] = (unsigned char) obj->id();
    dataBuffer[2] = PYCONNECT_MSG_END;
    this->dispatchMessage( dataBuffer, 3 );
  
    // threadsafe lock
    PyGILState_STATE gstate;
    gstate = PyGILState_Ensure();
    
    PyObject * arg = Py_BuildValue( "(si)", obj->name().c_str(), obj->id() );
    if (pow_) {
      invokeCallback( pow_->mainScript(), "onModuleDestroyed", arg );
    }
    else {
      invokeCallback( pPyConnect_, "onModuleDestroyed", arg );
    }
    Py_DECREF( arg );
    PyObject_DelAttrString( pPyConnect_, const_cast<char *>(obj->name().c_str()) );
    Py_DECREF( *miter );
    modules_.erase( miter );
    PyGILState_Release( gstate );
  }
}

void PyConnectStub::deleteModuleByID( int id )
{
  //DEBUG_MSG( "PyConnectStub::deleteModuleByID %d\n", id );
  PyModules::iterator miter = modules_.begin();

  while (!(miter == modules_.end() || (*miter)->id() == id)) miter++;

  if (miter != modules_.end()) {
    // threadsafe lock
    PyGILState_STATE gstate;
    gstate = PyGILState_Ensure();

    PyObject * arg = Py_BuildValue( "(si)", (*miter)->name().c_str(), id );
    if (pow_) {
      invokeCallback( pow_->mainScript(), "onModuleDestroyed", arg );
    }
    else {
      invokeCallback( pPyConnect_, "onModuleDestroyed", arg );
    }
    Py_DECREF( arg );
    PyObject_DelAttrString( pPyConnect_, const_cast<char *>((*miter)->name().c_str()) );
    Py_DECREF( *miter );
    modules_.erase( miter );
    PyGILState_Release( gstate );
  }
}

PyConnectObject * PyConnectStub::findModuleByName( std::string & name )
{
  PyModules::iterator miter = modules_.begin();

  while (!(miter==modules_.end() || (*miter)->name() == name)) miter++;

  if (miter==modules_.end())
    return NULL;
  else
    return *miter;  
}

PyConnectObject * PyConnectStub::findModuleByRef( PyObject * obj )
{
  PyConnectObject * searchObj = static_cast<PyConnectObject *> (obj);
  PyModules::iterator miter = modules_.begin();

  while (!(miter==modules_.end() || (*miter) == searchObj)) miter++;

  if (miter == modules_.end())
    return NULL;
  else
    return *miter;  
}

MesgProcessResult PyConnectStub::processInput( unsigned char * recData, int bytesReceived, struct sockaddr_in & cAddr, bool skipdecrypt )
{
  if (bytesReceived < 1) {
    ERROR_MSG( "PythonServer::processInput received empty data? Ignore.\n" );
    return MESG_PROCESSED_FAILED;
  }

  unsigned char * message = NULL;
  int messageSize = 0;
  
  if (skipdecrypt) {
    message = recData;
    messageSize = bytesReceived;
  }
  else {
    if (decryptMessage( recData, (int)bytesReceived, &message, (int *)&messageSize ) != 1) {
      WARNING_MSG( "Unable to decrypt incoming messasge.\n" );
      return MESG_PROCESSED_FAILED;
    }
  }

  int msgType = message[0] >> 4 & 0xf;
  if (msgType == 0) {
    ERROR_MSG( "PythonServer::processInput invalid message header! Ignore.\n" );
    return MESG_PROCESSED_FAILED;
  }
  //DEBUG_MSG( "PyConnectStub::processInput(): msgType %d\n", msgType );

  message++;
  PyConnectObject * pPyModule = NULL;
  int dummyLen = 0;
  int moduleId = 0;
  if (msgType == MODULE_DECLARE) {
    char modOpt = *message++;
    std::string mName = unpackString( message, dummyLen );
    pPyModule = findModuleByName( mName );
    if (pPyModule == NULL) {
      std::string mDesc = unpackString( message, dummyLen, true );
      addNewModule( mName, mDesc, modOpt, cAddr );
      return MESG_PROCESSED_OK;
    }
    else {
      WARNING_MSG( "PythonServer::processInput module %s already registered! Ignore.\n",
            mName.c_str() );
      return MESG_TO_SHUTDOWN; // we should reject the connection
    }
  }
  else if (msgType == MODULE_SHUTDOWN) {
    // find appropriate module
    moduleId = (int)(*message++ & 0xf);
    //DEBUG_MSG( "PyConnectStub:processInput: MODULE_SHUTDOWN id %d\n",
    //  moduleId );
    deleteModuleByID( moduleId );
    return MESG_TO_SHUTDOWN;
  }
  else if (msgType == PEER_SERVER_MSG) {
    int peerServerID = *(message - 1) & 0xf;
    std::string peerMsg = unpackString( message, dummyLen, true );
    // threadsafe lock
    PyGILState_STATE gstate;
    gstate = PyGILState_Ensure();

    PyObject * arg = Py_BuildValue( "(is)", peerServerID, peerMsg.c_str() );
    if (pow_) {
      invokeCallback( pow_->mainScript(), "onPeerMessage", arg );
    }
    else {
      invokeCallback( pPyConnect_, "onPeerMessage", arg );
    }
    Py_DECREF( arg );

    PyGILState_Release( gstate );
    return MESG_PROCESSED_OK;
  }
  else if (msgType == PEER_SERVER_DISCOVERY) {
    // TODO:: to be implemented
    return MESG_PROCESSED_OK;
  }
  else {
    // find appropriate module
    moduleId = (int)(*message++ & 0xf);
    pPyModule = findModuleByID( moduleId );
    if (pPyModule == NULL) {
      WARNING_MSG( "PythonServer::processInput: unable to find module with ID %d.\n",
        moduleId );
      return MESG_PROCESSED_FAILED;
    }
  }
  // threadsafe lock
  PyGILState_STATE gstate;
  gstate = PyGILState_Ensure();

  switch (msgType) {
    case ATTR_METD_EXPOSE:
    {
      //DEBUG_MSG( "PyConnectStub:processInput: ATTR_METD_EXPOSE\n" );
      // unpacking attributes
      int nofattrs = unpackStrToInt( message, dummyLen );
      for (int i = 0;i < nofattrs;i++) {
        bool readOnly = !(*message >> 6);
        PyConnectType::Type type =
          (PyConnectType::Type)(*message++ & 0x3f);
        std::string attrName = unpackString( message, dummyLen );
        PyObject * initValue = PyConnectType::unpackStr( type, message, dummyLen );
        pPyModule->addNewAttribute( attrName, type, readOnly, initValue );
      }

      // unpacking methods
      int nofmetds = unpackStrToInt( message, dummyLen );
      for (int i = 0;i < nofmetds;i++) {
        PyConnectType::Type type = (PyConnectType::Type)(*message++ & 0x3f);
        std::string metdName = unpackString( message, dummyLen );
        int nofargs =(int)(*message++ & 0xf);
        pyArguments args;
        int optArgs = 0;
        for (int j = 0;j < nofargs;j++) {
          bool optional = !!(*message >> 6);
          if (optional) optArgs++;
          PyConnectType::Type type = 
            (PyConnectType::Type)(*message++ & 0x3f);
          args.push_back( new PyConnectArgument( type, optional ) );
        }
        pPyModule->addNewMethod( metdName, type, args, optArgs );
      }
      PyObject * arg = Py_BuildValue( "(O)", pPyModule );
      if (pow_) {
        invokeCallback( pow_->mainScript(), "onModuleCreated", arg );
      }
      else {
        invokeCallback( pPyConnect_, "onModuleCreated", arg );
      }
      Py_DECREF( arg );
    }
      break;
    case ATTR_METD_RESP:
    {
      //DEBUG_MSG( "PyConnectStub:processInput: ATTR_METD_RESP\n" );
      int err = (int) (*message++ & 0xf);
      int datalen = 0;
      int dummyLen = 0;
      unpackLENumber( datalen, message, dummyLen );  // assume both server and client conform to same interger definition
      int amind = unpackStrToInt( message, datalen );
      pPyModule->onSetAttrMetdResp( amind, err, message, datalen );
    }
      break;
    case ATTR_VALUE_UPDATE:
    {
      //DEBUG_MSG( "PyConnectStub:processInput: ATTR_VALUE_UPDATE\n" );
      int err = (int)(*message++ & 0xf);
      int datalen = 0;
      int dummyLen = 0;
      unpackLENumber( datalen, message, dummyLen );  // assume both server and client conform to same interger definition
      int amind = unpackStrToInt( message, datalen );
      pPyModule->onGetAttrResp( amind, err, message, datalen );
    }
      break;
    case ATTR_METD_DESC:
    {
      pPyModule->onSetAttrMetdDesc( message, dummyLen );
    }
      break;
    default:
      ERROR_MSG( "PythonServer::processInput invalid message header! Ignore.\n" );
      return MESG_PROCESSED_FAILED;
  }
  PyGILState_Release( gstate );
  
  if (*message++ != PYCONNECT_MSG_END) {
    WARNING_MSG( "PythonServer::processInput: possible message corruption. msg id %d\n",
        msgType );
  }

  return MESG_PROCESSED_OK;
}

PyConnectMethod::PyConnectMethod( PyConnectObject * owner, std::string & name,
  PyConnectType::Type type, pyArguments & args, int optArgs ) :
  owner_( owner ),
  name_( name ),
  type_( type ),
  args_( args ),
  optArgs_( optArgs )
{
  PyObject_INIT( this, &PyConnectMethodType );

  id_ = (int)owner_->pPyMetds_.size();
  myMetdDef_.ml_name = const_cast<char *>(name_.c_str());
  myMetdDef_.ml_meth = (PyCFunction)&(PyConnectMethod::pyCallRouter);
  myMetdDef_.ml_flags = METH_VARARGS;
  myMetdDef_.ml_doc = 0;
  pyFunction_ = PyCFunction_New( &myMetdDef_, this );
  ownerClassObj_ = PyObject_GetAttrString( owner_, "__class__" );
#if PY_MAJOR_VERSION >= 3
  metdObj_ = PyMethod_New( pyFunction_, owner_ );
#else
  metdObj_ = PyMethod_New( pyFunction_, owner_, ownerClassObj_ );
#endif
}

PyObject * PyConnectMethod::pyCallRouter( PyObject * self, PyObject * args )
{
  return static_cast<PyConnectMethod *>(self)->pyCall( args );
}

PyObject * PyConnectMethod::pyCall( PyObject * args )
{
  int argSize = (int)PyTuple_Size( args ) - 1; // remove first self argument
  int minReqArgs = (int)args_.size() - optArgs_;

  if (argSize < minReqArgs ||
      argSize > minReqArgs + optArgs_)
  {
    PyErr_Format( PyExc_TypeError, "%s() requires %s%d arguments, "
      "total %d arguments.", name_.c_str(), 
      (optArgs_) ? "at least " : "", minReqArgs, 
      minReqArgs + optArgs_ );
    return NULL;
  }

  //DEBUG_MSG( "Method id %d. nof real args %d minimum req args %d, total args %d\n",
  //  id_, argSize, minReqArgs, minReqArgs + optArgs_ );
  
  PyObject * pItem = NULL;
  int totalArgSize = 0;
  unsigned char * argsBuf = NULL;
  if (argSize > 0) {
    PyObject ** argList = new PyObject *[argSize];
    for (int i = 0;i < argSize;i++) {
      pItem = PyTuple_GetItem( args, i+1 );
      int sizeReq = PyConnectType::validateTypeAndSize( pItem, args_[i]->type() );
      if (!sizeReq) {
        PyErr_Format( PyExc_ValueError, "%s(): argument %d is not a %s",
              name_.c_str(), i+1, PyConnectType::typeName( args_[i]->type() ).c_str() );
        delete [] argList;
        return NULL;
      }
      argList[i] = pItem;
      Py_INCREF( pItem );
      totalArgSize += sizeReq;
    }

    argsBuf = new unsigned  char[totalArgSize];
    unsigned char * dataPtr = argsBuf;
    if (owner_->argEvalReversed_) {
      for (int i = 0;i < argSize; i++) {
        PyConnectType::packToStr( argList[i], args_[i]->type(), dataPtr );
        Py_XDECREF( argList[i] );
      }
    }
    else {
      for (int i = argSize-1;i >= 0; i--) {
        PyConnectType::packToStr( argList[i], args_[i]->type(), dataPtr );
        Py_XDECREF( argList[i] );
      }
    }
    delete [] argList;
  }
  int mindex = (int)owner_->pPyAttrs_.size() + id_;
  if (owner_->noCallback_) {
    PyConnectStub::instance()->remoteAttrMethodCall( owner_, mindex, argsBuf, totalArgSize, CALL_ATTR_METD_NOCB );
  }
  else {
    PyConnectStub::instance()->remoteAttrMethodCall( owner_, mindex, argsBuf, totalArgSize );
  }
  if (argsBuf)
    delete [] argsBuf;
  Py_RETURN_NONE;
}

PyConnectMethod::~PyConnectMethod()
{
  for (pyArguments::iterator iter = args_.begin();
     iter != args_.end(); iter++)
  {
    delete *iter;
  }
  args_.clear();
}

void PyConnectStub::sendDiscoveryMsg( bool broadcast )
{
  if (!s_pPyConnectStub)
    return;

  unsigned char dataBuffer[2];
  
  dataBuffer[0] = (unsigned char) (MODULE_DISCOVERY << 4 | (this->serverID_ & 0xf));
  dataBuffer[1] = PYCONNECT_MSG_END;

  s_pPyConnectStub->dispatchMessage( dataBuffer, 2, broadcast );
}

void PyConnectStub::sendPeerMessage( char * mesg )
{
  if (!s_pPyConnectStub)
    return;

  int msgLen = (int)strlen( mesg );
  int dsl = packedIntLen( msgLen );
  int dataLength = msgLen + dsl + 2;
  unsigned char * dataBuffer = new unsigned char[dataLength];

  unsigned char * bufPtr = dataBuffer;

  *bufPtr = (unsigned char) (PEER_SERVER_MSG << 4 | (this->serverID_ & 0xf)); bufPtr++;
  packString( (unsigned char *)mesg, msgLen, bufPtr, true );
  *bufPtr = PYCONNECT_MSG_END;

  s_pPyConnectStub->dispatchMessage( dataBuffer, dataLength, true );
  delete [] dataBuffer;
}

PyObject * PyConnectStub::PyConnect_discover( PyObject * self )
{
  s_pPyConnectStub->sendDiscoveryMsg();
  Py_RETURN_NONE;
}

PyObject * PyConnectStub::PyConnect_write( PyObject *self, PyObject * args )
{
  char * msg;
  std::string outputMsg;

  if (!s_pPyConnectStub || !s_pPyConnectStub->pow_)
    Py_RETURN_NONE;

  if (!PyArg_ParseTuple( args, "s", &msg )) {
    // PyArg_ParseTuple will set the error status.
    return NULL;
  }
  
  // Next send it to all (active) clients.
  while (*msg) {
    if (*msg == '\n')
      outputMsg += "\r\n";
    else
      outputMsg += *msg;
    msg++;
  }

  s_pPyConnectStub->pow_->write( outputMsg.c_str() );
  
  Py_RETURN_NONE;
}

PyObject * PyConnectStub::PyConnect_disconnect( PyObject *self, PyObject * args )
{
  if (!s_pPyConnectStub)
    Py_RETURN_NONE;
  
  PyObject * obj;
  PyConnectObject * pyConnectbj = NULL;

  if (!PyArg_ParseTuple( args, "O", &obj )) {
    // PyArg_ParseTuple will set the error status.
    return NULL;
  }
#if PY_MAJOR_VERSION >=  3
  if (PyUnicode_Check( obj )) {
    PyObject * unicodeobj = PyUnicode_FromObject( obj );
    std::string objName = PyUnicode_AsUTF8( unicodeobj );
    Py_DECREF( unicodeobj );
#else
  if (PyString_Check( obj )) {
    std::string objName = PyString_AsString( obj );
#endif
    pyConnectbj = PyConnectStub::instance()->findModuleByName( objName );
  }
  else if (PyObject_IsInstance(obj, (PyObject *) &PyConnectObjectType)) {
    pyConnectbj = PyConnectStub::instance()->findModuleByRef( obj );
  }
  else {
    PyErr_Format( PyExc_TypeError, "Input argument is not string object or a PyConnect object." );
    return NULL;
  }

  if (!pyConnectbj) {
    PyErr_Format( PyExc_LookupError, "Unable to find a live PyConnect object correspoding to the input." );
    return NULL;
  }
  INFO_MSG( "Attempt to delete module %s id %d\n", pyConnectbj->name().c_str(), pyConnectbj->id() );
  PyConnectStub::instance()->shutdownModuleByRef( pyConnectbj );

  Py_RETURN_NONE;  
}

PyObject * PyConnectStub::PyConnect_connect( PyObject *self, PyObject * args )
{
  if (!s_pPyConnectStub)
    Py_RETURN_NONE;

  char * addr;
  int port = 0;
  if (!PyArg_ParseTuple( args, "s|i", &addr, &port )) {
    // PyArg_ParseTuple will set the error status.
    return NULL;
  }

  bool commFailed = true;
  CommObjectStat ret = s_pPyConnectStub->connectTo( addr, port );
  if (ret & COMM_FAILED) {
    PyErr_Format( PyExc_IOError,
      "PyConnect.connect: unable to connect PyConnect component on %s!", addr );
  }
  else if (ret & INVALID_ADDR_PORT) {
    PyErr_Format( PyExc_ValueError,
      "PyConnect.connect: invalid PyConnect component address:port!" );
  }
  else if (ret & NOT_SUPPORTED) {
    PyErr_Format( PyExc_NotImplementedError,
      "PyConnect.connect: No underlying comm object support!" );
  }
  else { // COMM_SUCCESS
    s_pPyConnectStub->sendDiscoveryMsg( false );
    commFailed = false;
  }
  if (commFailed)
    return NULL;
  else
    Py_RETURN_NONE;
}

PyObject * PyConnectStub::PyConnect_set_broadcast( PyObject * self, PyObject * args )
{
  if (!s_pPyConnectStub)
    Py_RETURN_NONE;

  char * msg;
  if (!PyArg_ParseTuple( args, "s", &msg )) {
    // PyArg_ParseTuple will set the error status.
    return NULL;
  }
  CommObjectStat ret = s_pPyConnectStub->setBroadcastAddr( msg );
  if (ret & COMM_FAILED) {
    PyErr_Format( PyExc_IOError,
      "PyConnect.set_broadcast: unable to set broadcast address to %s!", msg );
    return NULL;
  }
  else if (ret & INVALID_ADDR_PORT) {
    PyErr_Format( PyExc_ValueError,
      "PyConnect.set_broadcast: invalid broadcast address!" );
    return NULL;
  }
  else if (ret & NOT_SUPPORTED) {
    PyErr_Format( PyExc_NotImplementedError,
      "PyConnect.set_broadcast: No underlying comm object support!" );
    return NULL;
  }
  s_pPyConnectStub->sendDiscoveryMsg();
  Py_RETURN_NONE;
}

PyObject * PyConnectStub::PyConnect_send_peer_msg( PyObject * self, PyObject * args )
{
  if (!s_pPyConnectStub)
    Py_RETURN_NONE;

  char * msg;
  
  if (!PyArg_ParseTuple( args, "s", &msg )) {
    // PyArg_ParseTuple will set the error status.
    return NULL;
  }
  
  s_pPyConnectStub->sendPeerMessage( msg );

  Py_RETURN_NONE;
}
// helper method to call python function or object method
void PyConnectStub::invokeCallback( PyObject * module, const char * fnName, PyObject * arg )
{
  if (!module)
    return;

  //DEBUG_MSG( "Attempt get callback function %s\n", fnName );

  PyObject * callbackFn = PyObject_GetAttrString( module, const_cast<char *>(fnName) ); 
  if (!callbackFn) {
    PyErr_Clear();
    return;
  }
  else if (!PyCallable_Check( callbackFn )) {
    PyErr_Format( PyExc_TypeError, "%s is not callable object", fnName );
  }
  else {
    PyObject * pResult = PyObject_CallObject( callbackFn, arg );
    if (PyErr_Occurred()) {
      PyErr_Print();
    }
    Py_XDECREF( pResult );
  }
  Py_DECREF( callbackFn );
}
  
} // namespace pyconnect