PydtnApplication.cc

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn 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.
//
// pydtn 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 pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#include "simlpy/interpreter_hooks.h"
#include "parsers.h"
#include "PydtnApplication.h"
#include "PydtnBundle.h"
#include "WrapNode.h"

#include <iostream>

#include "simlpy/SimulationException.h"


static PyObject* PydtnAppObject_new( PyTypeObject* type,
                                     PyObject* args,
                                     PyObject* kwds );

static void
PydtnAppObject_dealloc( PydtnAppObject* self )
{
   if ( 0 == self ) return;
   if ( 0 != self->proc ) Py_DECREF(self->proc);
   if ( 0 != self->node ) Py_DECREF(self->node);
   if ( 0 != self->app ) delete self->app;
   self->ob_type->tp_free((PyObject*)self);
}

static PyObject*
PydtnAppObject_repr( PyObject* self )
{
   return construct_string("");
}

static PyObject*
PydtnAppObject_appID( PydtnAppObject* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->app ) return 0;
   PyObject* retval = self->app->pyid();
   Py_INCREF(retval);
   return retval;
}

static PyObject*
PydtnAppObject_process( PydtnAppObject* self, PyObject* args )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->proc ) return 0;
   if ( 0 == args ) return 0;
   PyObject* newArgs = PyTuple_New(2);
   if ( 0 == newArgs )
   {
      PyErr_SetString( PyExc_MemoryError, "could not allocate tuple" );
      return 0;
   }
   Py_INCREF(self);
   PyObject* r = 0;
   try
   {
      PyTuple_SetItem( args, 0, (PyObject*)self );
      if ( ! PyTuple_Check(args) )
      {
         PyErr_SetString( PyExc_TypeError, "expected a tuple" );
         throw SimulationException( __FILE__ , __LINE__ );
      }
      PyObject* b = PyTuple_GetItem(args,0);
      if ( 0 == b )
      {
         throw SimulationException( __FILE__ , __LINE__ );
      }
      Py_INCREF(b);
      PyTuple_SetItem( args, 1, b );
      r = PyObject_Call(self->proc,args,0);
   }
   catch ( ... )
   {
      Py_DECREF(self);
   }
   Py_DECREF(newArgs);
   return r;
}

static char PydtnAppObject_doc[] =
"Define an application as a Python object.\n\
   \n\
   This is a Python class that can be used as a DTN::Application\n\
   in a simulation.  The application identifier and process()\n\
   method can be specified dynamically when the object is created.\n\
   The syntax for creating a pydtn.Application is:\n\
   \n\
      app = pydtn.Application(node,identifier,proc)\n\
   \n\
   where:\n\
      node       is a sim.Entity of type 'node'\n\
      identifier is a string uniquely identifying an application type\n\
      proc       is a function or other callable object\n\
   \n\
   While proc is defined separate from the class, it should look like\n\
   a class method:\n\
   \n\
      def proc(self,b):\n\
         # do something with pydtn.Bundle b\n\
   \n\
   The owner node is available as app.node (or self.node in proc).\n\
   \n\
   You can call proc directly with a pydtn.Bundle, and it will be\n\
   treated as if the bundle was received over the network:\n\
   \n\
      app.process(b)\n\
   \n\
   Note that any functionality required by proc must be provided in\n\
   some additional way.  In particular, if you want to send bundles,\n\
   you need to provide some hook for doing so.\n\
   \n\
   Attaching a pydtn.Application to all nodes might be accomplished\n\
   with code similar to the following:\n\
   \n\
      pydtn.mobility.applyToNodes( pydtn.Application, identifier, proc )\n\
   \n\
   Note that this does not give you handles to the pydtn.Applications\n\
   created.  You could create a helper function to do this, or inherit\n\
   pydtn.Application in a class that maintains its own mapping from\n\
   nodes to applications.\n\
   \n";

static PyMethodDef PydtnAppObject_methods[] =
{
   { "appID",   (PyCFunction)PydtnAppObject_appID,   METH_NOARGS,
     "returns the application identifier" },
   { "process", (PyCFunction)PydtnAppObject_process, METH_VARARGS,
     "process a pydtn.Bundle as if it were received over the network" },
   {0} // sentinel
};

static PyMemberDef PydtnAppObject_members[] =
{
   { "node", T_OBJECT_EX, offsetof(PydtnAppObject, node), READONLY,
     "the owner node" },
   {0} // sentinel
};

static PyTypeObject PydtnAppObjectType = {
   PyObject_HEAD_INIT(0)
   0,                                  // ob_size
   "pydtn.Application",                // tp_name
   sizeof(PydtnAppObject),             // tp_basicsize
   0,                                  // tp_itemsize
   (destructor)PydtnAppObject_dealloc, // tp_dealloc
   0,                                  // tp_print
   0,                                  // tp_getattr
   0,                                  // tp_setattr
   0,                                  // tp_compare
   PydtnAppObject_repr,                // 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
   PydtnAppObject_doc,                 // tp_doc
   0,                                  // tp_traverse
   0,                                  // tp_clear
   0,                                  // tp_richcompare
   0,                                  // tp_weaklistoffset
   0,                                  // tp_iter
   0,                                  // tp_iternext
   PydtnAppObject_methods,             // tp_methods
   PydtnAppObject_members,             // 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
   PydtnAppObject_new,                 // tp_new
};

static PyObject*
PydtnAppObject_new( PyTypeObject* type, PyObject* args, PyObject* kwds )
{
   if ( 0 == args )
   {
      PyErr_SetString( PyExc_TypeError, "expected arguments" );
      return 0;
   }
   Entity::ArgList appArgs;
   WrapNode* wn;
   PyObject* node;
   PyObject* id;
   PyObject* proc;
   try
   {
      build_arglist( appArgs, args );
      if ( 3 != appArgs.size() )
      {
         PyErr_SetString(PyExc_TypeError,"three arguments expected");
         throw SimulationException( __FILE__ , __LINE__ );
      }
      node = appArgs[0];
      wn = parse_node( node );
      id = appArgs[1];
      if ( ! PyString_Check( id ) )
      {
         PyErr_SetString(PyExc_TypeError,"expected a string");
         throw SimulationException( __FILE__ , __LINE__ );
      }
      proc = appArgs[2];
      if ( ! PyCallable_Check( proc ) )
      {
         PyErr_SetString(PyExc_TypeError,"expected a callable object");
         throw SimulationException( __FILE__ , __LINE__ );
      }
   }
   catch ( ... )
   {
      clean_arglist(appArgs);
      return 0;
   }
   clean_arglist(appArgs);

   PydtnAppObject* self =
      (PydtnAppObject*)PydtnAppObjectType.tp_alloc(&PydtnAppObjectType,0);
   if ( 0 == self )
   {
      std::cerr << "Could not allocate a new pydtn.Application" << std::endl;
      return 0;
   }

   self->app = new PydtnApplication( self, id );
   wn->addApplication( self->app );
   Py_INCREF(proc); self->proc = proc;
   Py_INCREF(node); self->node = node;

   Py_INCREF(self);
   return (PyObject*)self;
}

void
addType_PydtnAppObject( PyObject* m )
{
   if ( 0 == m ) return;
   if ( PyType_Ready(&PydtnAppObjectType) < 0 ) return;
   Py_INCREF(&PydtnAppObjectType);
   PyModule_AddObject(m,"Application",(PyObject*)&PydtnAppObjectType);
}

int
PydtnAppObject_Check( PyObject* o )
{
   if ( 0 == o ) return 0;
   return PyObject_TypeCheck(o,&PydtnAppObjectType);
}

PydtnApplication::PydtnApplication( PydtnAppObject* pyapp,
                                    PyObject* pyappID ) :
   DTN::Application()
{
   if ( 0 == pyapp )
   {
      throw SimulationException( __FILE__ , __LINE__ );
   }
   if ( 0 == pyappID )
   {
      PyErr_SetString( PyExc_AttributeError,
                       "Application requires an identifier" );
      throw SimulationException( __FILE__ , __LINE__ );
   }
   if ( ! PyString_Check(pyappID) )
   {
      PyErr_SetString( PyExc_TypeError,
                       "application identifier must be a string" );
      throw SimulationException( __FILE__ , __LINE__ );
   }

   Py_INCREF(pyapp); m_pyapp = pyapp;
   Py_INCREF(pyappID); m_pyid = pyappID;

   char* buff = NULL;
   int bufflen = 0;
   if ( -1 != PyString_AsStringAndSize(pyappID,&buff,&bufflen) )
   {
      for ( int i = 0 ; i < bufflen ; ++i )
      {
         m_appID += (unsigned char)(buff[i]);
      }
   }
}

PydtnApplication::~PydtnApplication()
{
   if ( 0 != m_pyid ) Py_DECREF(m_pyid);
}

PyObject*
PydtnApplication::pyid()
{
   return m_pyid; // borrowed reference
}

void
PydtnApplication::process( const DTN::Bundle& b )
{
   if ( 0 == m_pyapp ) return;
   if ( 0 == m_pyapp->proc ) return;
   if ( ! PyCallable_Check(m_pyapp->proc) ) return;
   PyObject* args = PyTuple_New(2);
   if ( 0 == args )
   {
      PyErr_SetString( PyExc_MemoryError, "could not allocate tuple" );
      throw SimulationException( __FILE__ , __LINE__ );
   }
   Py_INCREF(m_pyapp);
   PyTuple_SetItem( args, 0, (PyObject*)m_pyapp );
   PyTuple_SetItem( args, 1, PydtnBundle_wrapBundle(b) );
   PyObject* r = PyObject_Call(m_pyapp->proc,args,0);
   if ( 0 != r ) Py_DECREF(r); // we don't use it
   Py_DECREF(args);
   if ( 0 == r )
   {
      if ( 0 != PyErr_Occurred() ) PyErr_Print();
      throw SimulationException( __FILE__ , __LINE__ );
   }
}

---