Search  

---

C:/temp/src/j2k/nto/cs4.cpp

Go to the documentation of this file.

#ifndef __J2K__CS4_CPP__
#define __J2K__CS4_CPP__

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <pthread.h>
#include <sys/neutrino.h>
#include <sys/dispatch.h>
#include <sync.h>
#include <time.h>

#include <j2k/nto/Basic_PThread.hpp>
#include <j2k/nto/Basic_PThread.cpp>
#include <j2k/nto/Message.hpp>
#include <j2k/nto/Message.cpp>
#include <j2k/nto/NameSpace.hpp>
#include <j2k/nto/NameSpace.cpp>

#include <j2k/nto/MsgContainer.hpp>
#include <j2k/nto/MsgContainer.cpp>

#include <j2k/nto/TimerPulse.hpp>
#include <j2k/nto/TimerPulse.cpp>

#define MAX_CLIENTS  3

class Server;
class Client;
class Timeout;
class Timeout : public TimerPulse, MsgContainer
{
protected:
  ULONG delay_nsec;
  ULONG delay_sec;
public:

  Timeout( NameSpace* n0, ULONG nsec0, ULONG sec0 )
   : TimerPulse( nsec0, sec0 ), MsgContainer( n0, client ),
     delay_nsec( nsec0 ), delay_sec( sec0 )
  { 
    message->setRequest( MQI_TIMEOUT );
    message->setStatus(  MQI_TIMEOUT );
  }

  virtual void tick( int signo )
  {
    printf( "#" );
    fflush( stdout );

    if ( message->send( fd, replyMsg ) < 0 )
    {
      perror( "Couldn't send Timeout Message ! \n" );
    }
  }

  virtual void start()
  {
    connect();

    printf( "Timer started.\n" );
    fflush( stdout ); 

    TimerPulse::start();
  }

  virtual ~Timeout()
  { 
  }

  virtual void run()
  {
  }

  void reset()
  {
    set( delay_nsec, delay_sec );
  }

  inline int              Timeout::getNumber()         { return message->getNumber();   }
  inline void             Timeout::setNumber( int nb ) { message->setNumber( nb );      }
  inline int              Timeout::getRequest()        { return message->getRequest();  }
  inline void             Timeout::setRequest( int r ) { message->setRequest( r );      }
  inline int              Timeout::getStatus()         { return message->getStatus();   }
  inline void             Timeout::setStatus( int s )  { message->setStatus( s );       }
  inline int              Timeout::getIndex()          { return message->getIndex();    }
  inline void             Timeout::setIndex( int i )   { message->setIndex( i );        } 

}; // End of Timeout


class Server
  : public Basic_PThread, MsgContainer
{
private:
  Timeout** t;

public:
  Server( NameSpace* n0 )
    : Basic_PThread(), MsgContainer( n0, server ) 
  { 
    t = new Timeout*[ MAX_CLIENTS ];
    register int i = 0;
    for( i = 0; i < MAX_CLIENTS; i++ )
    {
      t[i] = new Timeout( n0, 0, 5 ); // 5 sec
    }
  }

  virtual ~Server() 
  { 
    register int i = 0;
    for( i = 0; i < MAX_CLIENTS; i++ )
    {
      if ( t[i] != NULL)
      {
        delete t[i];
        t[i] = NULL;
      }
    }
    delete[] t;
  }

  /*** Server Side of the code ***/
  virtual void run()
  {
    printf( "Server run \n" );

    connect();

    printf( "Server attached \n" );

    /* Do your MsgReceive's here now with the chid */
    while( 1 ) 
    {
      int rcvid = message->receive( n->getChannel() ); 

      if ( message->checkHeader( rcvid ) < 0 ) break;

      /* A message (presumable ours) received, handle */
      printf("Server receive %d \n", message->getNumber() );

      int data = 100;
      message->reply( rcvid, data );
    }

    disconnect();
  }
};

/*** Client Side of the code ***/
class Consumer 
  : public Basic_PThread, MsgContainer
{
public:
  Consumer( NameSpace* n0, int idx = 0 ) 
    : Basic_PThread(), MsgContainer( n0, client ) 
  { 
    message->setRequest( MQI_CONSUMER );
    message->setIndex( idx );
  }

  virtual ~Consumer() { }

  /*** Consumer Side of the code ***/
  virtual void run()
  {
    printf( "Consumer run \n" );

    connect();

    printf( "Consumer opened a connection \n" );

    /* Do whatever work you wanted with server connection */
    register int i = 0;
     
    for ( i = 0; i < 5; i++ ) 
    {
      printf("Consumer sending %d \n", i );

      message->setNumber( i );

      if ( message->send( fd, replyMsg ) < 0 )
      {
        perror( "Couldn't send Message ! \n" );
        break;
      }
    }

    disconnect();
  }
};

/*** Producer Side of the code ***/
class Producer 
  : public Basic_PThread, MsgContainer
{
public:
  Producer( NameSpace* n0, int idx = 0 )
    : Basic_PThread(), MsgContainer( n0, client ) 
  { 
    message->setRequest( MQI_PRODUCER );
    message->setIndex( idx );
  }

  virtual ~Producer() { }

  /*** Producer Side of the code ***/
  virtual void run()
  {
    printf( "Producer run \n" );

    connect();

    printf( "Producer opened a connection \n" );

    /* Do whatever work you wanted with server connection */
    register int i = 0;
     
    for ( i = 0; i < 5; i++ ) 
    {
      printf("Producer sending %d \n", i );

      message->setNumber( i );

      if ( message->send( fd, replyMsg ) < 0 )
      {
        perror( "Couldn't send Message ! \n" );
        break;
      }
    }

    disconnect();
  }
};

int main( int argc, char **argv ) 
{
  NameSpace* n = new NameSpace( "myname", 3 );

  Server s( n );
  Producer p( n );
  Consumer c( n );

  s.start();

  n->waitForServer();

  p.start();
  c.start();

  pthread_join( c.getPID(), NULL );

  n->waitForClient();

  printf( "Main Done \n" );

  // Shut down the READ-Blocked server
  pthread_kill( s.getPID(), SIGKILL );

  if ( n != NULL ) delete n;

  return 0;
}

#endif // End of CS4.cpp

---