WrapLink.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_defs.h"
#include "simlpy/interpreter_hooks.h"

#include <iostream>

#include "WrapLink.h"
#include "WrapNode.h"
#include "parsers.h"
#include "BundleEvent.h"
#include "LinkUpDownEvent.h"
#include "AliasLink.h"
#include "Tracer.h"

#include "simlpy/Clock.h"
#include "simlpy/SimulationException.h"

WrapLink::WrapLink() :
   m_source( 0 ),
   m_destination( 0 ),
   m_link( this )
{
   // Without configuration, there's no reason to generate trace information.
}

WrapLink::~WrapLink()
{
}

Entity*
WrapLink::create() const
{
   return new WrapLink;
}

void
WrapLink::configure( const ArgList& args )
{
   unsigned int nargs = args.size();
   if ( 0 == nargs )
   {
      std::cerr << "no configuration options were passed" << std::endl;
      throw SimulationException( __FILE__ , __LINE__ );
   }
   std::string command = parse_string(args[0]);
   if ( "latency" == command )
   {
      if ( 2 != nargs )
      {
         std::cerr << "config('latency',dt) requires exactly 2 arguments ("
                   << nargs << " given)"
                   << std::endl;
         throw SimulationException( __FILE__ , __LINE__ );
      }
      double lat = parse_double( args[1] );
      m_link.setLatency(lat);
   }
   else if ( "bandwidth" == command )
   {
      if ( 2 != nargs )
      {
         std::cerr << "config('bandwidth',bw) requires exactly 2 arguments ("
                   << nargs << " given)"
                   << std::endl;
         throw SimulationException( __FILE__ , __LINE__ );
      }
      double dbw = parse_double(args[1]);
      // convert from Mbps to bps
      unsigned long int bw = (unsigned long int)(1000000 * dbw);
      m_link.setBandwidth(bw);
   }
   else if ( "connect" == command )
   {
      if ( 3 != nargs )
      {
         std::cerr
            << "config('connect',src,dest) requires exactly 3 arguments ("
            << nargs << " given)"
            << std::endl;
         throw SimulationException( __FILE__ , __LINE__ );
      }
      WrapNode* src = parse_node( args[1] );
      WrapNode* dest = parse_node( args[2] );
      if ( ( 0 == src ) || ( 0 == dest ) )
      {
         std::cerr << "The second and third arguments of "
                   << "config('connect',src,dest) must be nodes"
                   << std::endl;
         throw SimulationException( __FILE__ , __LINE__ );
      }
      m_source = src;
      m_destination = dest;
      if ( 0 != m_source )
      {
         m_source->addLink( new AliasLink( &m_link ) );
      }
   }
   else
   {
      std::cerr << "Unrecognized configuration for config(): "
                << command
                << std::endl;
      throw SimulationException( __FILE__ , __LINE__ );
   }

   // We've been re-configured, so it's time to create trace information.
   GlobalTracer* gt = GlobalTracer::instance();
   if ( 0 != gt )
   {
      gt->link(*this);
   }
}

void
WrapLink::emit( const ArgList& args )
{
   unsigned int nargs = args.size();
   if ( nargs < 2 )
   {
      std::cerr << "emit() requires at least 2 arguments ("
                << nargs << " given)"
                << std::endl;
      throw SimulationException( __FILE__ , __LINE__ );
   }

   Time t = parse_time(args[0]);

   std::string command = parse_string(args[1]);
   if ( "up" == command )
   {
      Clock::schedule( new LinkUpDownEvent(this,this,t,true) );
   }
   else if ( "down" == command )
   {
      Clock::schedule( new LinkUpDownEvent(this,this,t,false) );
   }
   else
   {
      std::cerr << "Unrecognized event: " << command << std::endl;
      throw SimulationException( __FILE__ , __LINE__ );
   }
}

InterpreterItem
WrapLink::get( const ArgList& args )
{
   unsigned int nargs = args.size();
   if ( 0 == nargs )
   {
      std::cerr << "No attribute specified" << std::endl;
      throw SimulationException( __FILE__ , __LINE__ );
   }

   std::string attr = parse_string(args[0]);

   if ( "bandwidth" == attr )
   {
      double bw = 0.000001 * m_link.bandwidth(); // convert from bps to Mpbs
      return construct_double( bw );
   }
   if ( "latency" == attr )
   {
      const Time& lat = m_link.latency();
      double t = lat.tv.tv_sec + 1.0 * lat.tv.tv_usec / Time::MILLION;
      return construct_double( t );
   }
   if ( "state" == attr )
   {
      return construct_string( m_link.up()? "up" : "down" );
   }

   // Pass the request up.
   return Entity::get(args);
}

bool
WrapLink::handler( BundleEvent& event )
{
   if ( m_link.up() )
   {
      if ( event.sentAt() >= m_link.upSince() )
      {
         Clock::schedule( new BundleEvent( this,
                                           m_destination,
                                           event.sentAt(),
                                           Clock::time(),
                                           event.pData() ) );
         return true;
      }
   }
   // If we get here, the Bundle is going to disappear.
   if ( 0 == m_source )
   {
      throw SimulationException( __FILE__ , __LINE__ );
   }
   m_source->drop( event.pData(), DTN::LinkFailureDrop::inst );
   return false;
}

bool
WrapLink::handler( LinkAvailEvent& event )
{
   m_link.setBusy(false);
   if ( ! m_link.up() ) return true;
   if ( 0 != m_source )
   {
      m_source->forwardOn( m_link );
   }
   return true;
}

bool
WrapLink::handler( LinkUpDownEvent& event )
{
   if ( event.state() )
   {
      m_link.setUp();
   }
   else
   {
      m_link.setDown();
   }

   GlobalTracer* gt = GlobalTracer::instance();
   if ( 0 != gt )
   {
      gt->link(*this);
   }

   return true;
}

---