HomeMadeServer.cc File Reference

#include "libMRML/include/GIFTExceptions.h"
#include <functional>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstdio>
#include <stdlib.h>
#include <cmath>
#include <ctime>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <cerrno>
#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <xmlparse.h>
#include "libMRML/include/CAttributeList.h"
#include "libMRML/include/CRelevanceLevelList.h"
#include "libGIFTAcInvertedFile/include/CDocumentFrequencyList.h"
#include "libGIFTAcInvertedFile/include/CAcInvertedFile.h"
#include "libGIFTQuInvertedFile/include/CQInvertedFile.h"
#include "libMRML/include/TID.h"
#include "libGIFTAcInvertedFile/include/WeightingFunctionsAndNormalizers.h"
#include "libMRML/include/CAccessorElement.h"
#include "libMRML/include/CIDRelevanceLevelPairList.h"
#include "libMRML/include/mrml_const.h"
#include "libMRML/include/CAccessorAdminCollection.h"
#include "libMRML/include/CSessionManager.h"
#include "libMRML/include/CAccessor.h"
#include "libMRML/include/CCommunicationHandler.h"

Go to the source code of this file.

Defines
#define	WOLFGANG_DEVELOPER
#define	_DEBUG
#define	_NON_BLOCKING   0
#define	_SOCKET_WORKAROUND
#define	WITH_GENERATE_DISTANCE_MATRIX
Functions
string	itoa (int val, int length)
string	dtoa (double val)
void	waitWriteStream (int inWritingSocket)
void	waitReadStream (int inReadingSocket)
void	waitExceptionStream (int inExceptioningSocket)
bool	sendMessage (int inSocket, string inString, ostream &outLogFile)
bool	asyncReadChar (int inSocket, char *outChar)
int	readMessage (int inSocket, string &outMessage)
void	generateDistanceMatrix (const string &inBaseDir, const string &inOutputName, const string &inAlgorithm, const string &inCollection, int inSkip, int inTo)
void	main (int argc, char **argv)
Variables
TID	gID
long	PORT = 12789

---

Define Documentation

#define _DEBUG

Definition at line 73 of file HomeMadeServer.cc.

#define _NON_BLOCKING   0

Definition at line 74 of file HomeMadeServer.cc.

Referenced by main().

#define _SOCKET_WORKAROUND

#define WITH_GENERATE_DISTANCE_MATRIX

Definition at line 338 of file HomeMadeServer.cc.

#define WOLFGANG_DEVELOPER

Definition at line 23 of file HomeMadeServer.cc.

---

Function Documentation

bool asyncReadChar	(	int	inSocket,
		char *	outChar
	)

Definition at line 308 of file HomeMadeServer.cc.

Referenced by readMessage().

                                              {
  waitReadStream(inSocket);
  if(read(inSocket, outChar, 1)>=0)
    return true;
  else
    return false;
}

string dtoa

(

double

val

)

Definition at line 109 of file HomeMadeServer.cc.

                         {

  char *car = new char[30];

  for(int i=0;
      i<30;
      i++){
    car[i]=0;
  };

  
  sprintf(car,"%f",val);

  return (string)car; 

}//..maybe this line is also by J. Raki ;-)

void generateDistanceMatrix	(	const string &	inBaseDir,
		const string &	inOutputName,
		const string &	inAlgorithm,
		const string &	inCollection,
		int	inSkip,
		int	inTo
	)

Definition at line 341 of file HomeMadeServer.cc.

References CXMLElement::addAttribute(), CXMLElement::addChild(), mrml_const::algorithm_id, mrml_const::algorithm_type, mrml_const::calculated_similarity, CXMLElement::child_list_begin(), CXMLElement::child_list_end(), mrml_const::collection_id, CAccessorImplementation::getAllAccessorElements(), CAccessorAdminCollection::getProxy(), mrml_const::image_location, CXMLElement::moveUp(), CSessionManager::newSession(), CSessionManager::query(), mrml_const::query_step, mrml_const::result_cutoff, mrml_const::result_size, CSessionManager::setAlgorithm(), CXMLElement::toXML(), mrml_const::user_relevance, mrml_const::user_relevance_element, and mrml_const::user_relevance_element_list.

Referenced by main().

                   {

  map<string,int> lURLToPosition;

  string lOutputName=inOutputName
    +string(".Algorithm")
    +inAlgorithm
    +string(".Collection")
    +inCollection
    +".bin";
    

  CSessionManager lSessionManager(inBaseDir+"/gift-sessions.mrml",
          inBaseDir+"/gift-config.mrml",
          inBaseDir+"/gift-i18n.xml");
  
  // open a session
  string lSessionID(lSessionManager.newSession("DistanceMatrixMaker",""));
  // configure the session
  CAlgorithm* lConfig(new CAlgorithm("algorithm",
             0));
  assert(lConfig);
  lConfig->addAttribute(mrml_const::algorithm_id,
      inAlgorithm);
  lConfig->addAttribute(mrml_const::algorithm_type,
      inAlgorithm);
  lConfig->addAttribute(mrml_const::collection_id,
      inCollection);
  
  lSessionManager.setAlgorithm(lSessionID,
             lConfig);


  fstream lMatrix(lOutputName.c_str(),
      fstream::in+fstream::out);

  cout << "----------------------------------------"
       << endl
       << "I am generating a distance matrix"
       << endl
       << "Using the algorithm:  " << inAlgorithm
       << endl
       << "Using the collection: " << inCollection << ","
       << endl
       << "I am skipping the first " << inSkip << " lines."
       << endl
       << "I am ending before the  " << inTo << "th  line"
       << endl
       << "----------------------------------------"
       << endl;

  cout << "----------------------------------------"
       << endl
       << "Getting a list of all IDs in the collection"
       << endl
       << "SessionID: " << lSessionID
       << endl
       << "AlgorithmID: " << inAlgorithm
       << endl
       << "CollectionID: " << inCollection
       << endl;


  /*
    Get an accessor. We need this for getting at a list
    of all the images. Mabe we do this later using 
    a meta data query and coming from the outside.
  */

  CAccessorAdminCollection lAccessorAdminCollection(inBaseDir+"/gift-config.mrml");
  CAccessorAdmin& lProxy(lAccessorAdminCollection.getProxy(inCollection));
  assert(&lProxy);
  CAcURL2FTS* lAccessor=(CAcURL2FTS*)lProxy.openAccessor("url2fts");
  assert(lAccessor);
  list<CAccessorElement> lAccessorElements; 
  lAccessor->getAllAccessorElements(lAccessorElements);
  
  if(lAccessorElements.size()){
    
    //for guaranteeing a sequence of rising IDs (probably obsolete)
    lAccessorElements.sort(CSortByID_CAE());
    
    int lSize=lAccessorElements.size();
    
    
    
    //write the translator if nothing to be skipped
    {
      ofstream lTranslator(string(lOutputName+".trans").c_str());
      int lLine=0;
      for(list<CAccessorElement>::const_iterator i=lAccessorElements.begin();
    i!=lAccessorElements.end();
    i++){
  lTranslator << i->getID()
        << " "
        << lLine
        << endl;
  lURLToPosition[i->getURL()]=lLine;
  lLine++;
      }
      inTo-=inSkip;
    }
    
    
    
    
    //skip the beginning
    {
      for(int i=0;
    i<inSkip;
    i++){
  lAccessorElements.pop_front();
      }
    }
    
    //skip the beginning also in the matrix
    lMatrix.seekp(lSize * inSkip * sizeof(float));
    
    
    int lCount=0;
    for(list<CAccessorElement>::const_iterator i=lAccessorElements.begin();
  i!=lAccessorElements.end() && lCount<inTo;
  i++,lCount++){

      
      cout    << "----------------------------------------"
        << endl
        << "querying for: " 
        << i->getID()
        << ": "
        << i->getURL()
        << endl;
      
      CXMLElement lQuery(mrml_const::query_step,0);
      lQuery.addAttribute(mrml_const::algorithm_id,
        inAlgorithm);
      lQuery.addAttribute(mrml_const::result_size,
        long(0x7fffffff));//simply get everything
      lQuery.addAttribute(mrml_const::result_cutoff,
        0.0);//and do not cut anything off
      
      CXMLElement* lUserRelevanceList=new CXMLElement(mrml_const::user_relevance_element_list,
                  0);
      assert(lUserRelevanceList);
      
      CXMLElement* lUserRelevanceElement=new CXMLElement(mrml_const::user_relevance_element,
               0);
      lUserRelevanceElement->addAttribute(mrml_const::user_relevance,
            1.0);
      lUserRelevanceElement->addAttribute(mrml_const::image_location,
            i->getURL());

      lQuery.addChild(lUserRelevanceList);
      lQuery.addChild(lUserRelevanceElement);
      lQuery.moveUp();
      lQuery.moveUp();
      
      string lXML;

      lQuery.toXML(lXML);
      
      cout << "XML:" 
     << lXML
     << endl
     << "----------------------------------------"
     << endl;
      
      CXMLElement* lResult=lSessionManager
  .query(lSessionID,
         lQuery);
      
      {
    string lString;
    lResult->toXML(lString);
    cout << lString 
         << endl;
      }

      float lOutVector[lSize];
      {//fill lOutVecor with zeroes
  for(float* p=lOutVector;
      p!=lOutVector+lSize;
      *(p++)=0){}
      }
      
      float lZero=0.0;
      int lLastPosition=0;
      
      for(CXMLElement::lCChildren::iterator k=lResult->child_list_begin();
          k!=lResult->child_list_end();
          k++){
        for(CXMLElement::lCChildren::iterator j=(*k)->child_list_begin();
      j!=(*k)->child_list_end();
      j++){
      string lURL=(*j)->stringReadAttribute(mrml_const::image_location).second;
      double lRelevanceLevel=(*j)->doubleReadAttribute(mrml_const::calculated_similarity).second;
      
      lOutVector[lURLToPosition[lURL]]=lRelevanceLevel;
      
      cout << endl << "[" << lURLToPosition[lURL] << "__" << lRelevanceLevel << "]" << flush;
        }
      }
      
      lMatrix.write(lOutVector,sizeof(float)*lSize);
      lMatrix << flush;
      delete lResult;
      
      cout << endl
     << "----------------------------------------"
     << "Writing " << sizeof(float)*lSize << " Bytes" << endl

     << "Still to go:" << inTo-lCount-1 << " lines."
     << endl
     << "----------------------------------------"
     << endl;

    }
    lMatrix.close();
  }else{

  }
}

string itoa	(	int	val,
		int	length
	)

Definition at line 94 of file HomeMadeServer.cc.

                                 {
  char *car = new char[length+1];

  for(int i=0;
      i<length+1;
      i++){
    car[i]=0;
  };

  
  sprintf(car,"%0*2$d",val,length);

  return (string)car; 
}

void main	(	int	argc,
		char **	argv
	)

Definition at line 580 of file HomeMadeServer.cc.

References _NON_BLOCKING, generateDistanceMatrix(), PORT, CCommunicationHandler::readAndParse(), CCommunicationHandler::setSocket(), and waitReadStream().

                                {

  string lConfigurationDirectory(getenv("GIFT_HOME")?getenv("GIFT_HOME"):"");
  if(!lConfigurationDirectory.size()){
    lConfigurationDirectory=(getenv("HOME")?getenv("HOME"):"");
  }

  cout << "GIFT 0.1.3" << endl
       << "Usage (server):              gift [<Port> [<Configuration-Directory>]]" << endl
       << "making distance matrices:    gift <Port(ignored)> <Configuration-Directory> <Algorithm> <Colection> <from> <to>" << endl
       << endl
       << endl;

  if(argc>1){
    PORT=atoi(argv[1]);
  }
  if(argc>2){
    lConfigurationDirectory=string(argv[2]);
  }

  // the communication handler for this application
  // class definition is just above in this file
  CCommunicationHandler gHandler(lConfigurationDirectory);




#ifdef WITH_GENERATE_DISTANCE_MATRIX
  if(argc==7){
    generateDistanceMatrix(lConfigurationDirectory,
         string("DistanceMatrix"),
         string(argv[3]),
         string(argv[4]),
         atoi(argv[5]),
         atoi(argv[6]));
    exit(0);
  }
#endif

  cout << "----------------------------------------"
       << endl
       << "The current configuration directory is: "
       << lConfigurationDirectory
       << endl;

  cout << "----------------------------------------"
       << endl
       << "Opening port " << PORT
       << endl
       << "----------------------------------------"
       << endl;

  int lSocketDescriptor;
  int lOutSocket;
  //a bound socket
  //this prototype is copied when accepting
  struct sockaddr_in lSocketAddress;
  //the copy made of the prototype when accepting
  struct sockaddr_in lSocketCopy; 
  
  lSocketAddress.sin_family = AF_INET ;
  /* get the port number */
  lSocketAddress.sin_port =  htons(PORT);
  lSocketAddress.sin_addr.s_addr = INADDR_ANY ;
  
  /* create a socket */
  if((lSocketDescriptor = socket(PF_INET,
         SOCK_STREAM,
         IPPROTO_TCP))<0) {
    printf("SOCKET error %s\n",strerror(errno)) ;
    
    exit(1) ;
  }

  

  int lOptionOn=1;
  if(0 > setsockopt(lSocketDescriptor,
        SOL_SOCKET,
        SO_REUSEADDR,
        (char*)&lOptionOn,
        sizeof(lOptionOn))){
      cerr << "could not set REUSEADDR: " 
     << strerror(errno)
     << flush 
     << endl;
      exit(1);
  };  
  if(0 > setsockopt(lSocketDescriptor,            /* socket affected */
        IPPROTO_TCP,     /* set option at TCP level */
        TCP_NODELAY,     /* name of option */
        (char *) &lOptionOn,  /* the cast is historical cruft */
          
        sizeof(lOptionOn))){
      cerr << "could not set NODELAY" 
     << strerror(errno)
     << flush 
     << endl;
      exit(1);
  }

  linger lLinger;
  lLinger.l_onoff=1;
  lLinger.l_linger=1000;//linger for ten seconds
  
  /* assigns a name to the socket */
  if(bind(lSocketDescriptor,
    (struct sockaddr *) &lSocketAddress ,
    sizeof(lSocketAddress) ) == -1 ) {
    printf("bind error: %s\n",strerror(errno)) ;
    exit(1) ;
  }
  
  /*listen to incoming connections */
  listen(lSocketDescriptor,
   5) ; /* backlog = 5 */
  
  /* loop to wait for connections */
  try{
    for(;;){
#ifdef HAVE_LIBSOCKET
       int lSocketCopySize = sizeof(lSocketCopy) ;
#else
       unsigned int lSocketCopySize = sizeof(lSocketCopy) ;
#endif
      /* accept a connection*/
      cout << "Waiting for a connection..." << endl << flush;
      if(1==_NON_BLOCKING){//setting non-blocking new
  long lArgument=0;
  long lReturnValue;
  lReturnValue=fcntl(lSocketDescriptor,F_GETFL,lArgument);
  cout << "before setNonBlocking:" << endl
       << "lReturnValue" << lReturnValue
       << "lArgument" << lArgument 
         << endl;
  lReturnValue |= O_NONBLOCK;
  fcntl(lSocketDescriptor,F_SETFL,lReturnValue);
  lReturnValue=fcntl(lSocketDescriptor,F_GETFL,lArgument);
  cout << "after setNonBlocking:" << endl
       << "lReturnValue" << lReturnValue
       << "lArgument" << lArgument 
       << endl;
      }
      if((lOutSocket=accept(lSocketDescriptor, 
          ( struct sockaddr * ) &lSocketCopy, 
          &lSocketCopySize)
    ) < 0 ) {

  cout << "Error when accepting connection"
       << strerror(errno)
       << endl;
  exit(1) ;
      }else{

  if(1==_NON_BLOCKING){//setting non-blocking 
    long lArgument=0;
    long lReturnValue;
    lReturnValue=fcntl(lOutSocket,F_GETFL,lArgument);
    cout << "Getting non blocking value for accepted connection:" << endl
         << "lReturnValue" << lReturnValue
         << "lArgument" << lArgument 
         << endl;
  }

  gHandler.setSocket(lOutSocket);
  cout << "Accepted Connection!" << endl << flush;
  if (!gHandler.readAndParse()) {
      printf("can't read from socket %s\n",strerror(errno)) ;
      //      exit(1) ;
  }

  cout << "flushing everything!"
       << endl;
  fflush(0);

  if(1==_NON_BLOCKING){
    cout << "wait for read!"
         << endl;
    waitReadStream(lOutSocket);
  }
  cout << "shutting down the socket!"
       << endl;
  //this is really embarassing
  shutdown(lOutSocket,
     1);
  sleep(1);
  close(lOutSocket);
      }
    }
  }
  catch(GIFTException& inCaught){
    cout << "Caught inServer Main:"
   << inCaught
   << endl
   << flush;
  }
  catch(...){
    cout << "there was an unknown exception" <<endl
   << flush;
  }
  //return 0;
} 

int readMessage	(	int	inSocket,
		string &	outMessage
	)

Definition at line 317 of file HomeMadeServer.cc.

                        { //J. Raki (obsolete)

  cout << "readMessage:" << flush;  

  char lChar[2];
  lChar[1]=0;

  while(asyncReadChar(inSocket,lChar)){
#ifdef _DEBUG
      cout << ValInt[0] 
     << flush;
#endif 
      
      outMessage += lChar;
  }

  return 0;
}

bool sendMessage	(	int	inSocket,
		string	inString,
		ostream &	outLogFile
	)

Definition at line 209 of file HomeMadeServer.cc.

Referenced by CCommunicationHandler::endMultiRequest(), and CCommunicationHandler::sendHandshake().

                          {
#ifdef _DEBUG
  cout << "Message to send: " 
       << inString 
       << "End of message to send"
       << endl 
       << flush;
#endif 

  {
    string lGIFTHome(".");
    
    if(getenv("HOME")){
      lGIFTHome=string(getenv("HOME"));
    }
      if(getenv("GIFT_HOME")){
  lGIFTHome=string(getenv("GIFT_HOME"));
      }
  
  {
    ofstream lOutLastMessageFile(string(lGIFTHome
                +string("/gift-last-out-message.mrml")).c_str());
    lOutLastMessageFile << inString
    << flush;
  }
  }

  outLogFile << inString 
       << flush;


  
  //i get problems when writing more than 64K to a socket.
#define _SOCKET_WORKAROUND
#ifdef _SOCKET_WORKAROUND
  int i=0;
  int lWriteSize=0x1000;

  // //this is really embarassing
  //sleep(1);
  
  waitWriteStream(inSocket);
  for(;
      i<inString.size()/lWriteSize;
      i++){
    int lOffset=i*lWriteSize;

    int lError=0;
    while((lError=write(inSocket,
      inString.c_str()+lOffset,
      lWriteSize) // The flags are none for the moment.
     <=0));
    
    if(lError>0){
      return false;
    }

    waitWriteStream(inSocket);
  }
  if(write(inSocket,
     inString.c_str()
     +i*lWriteSize,
     inString.size()%lWriteSize) // The flags are none for the moment.
     <=0 )
    return false;

#else
  if(write(inSocket,
     inString.c_str(),
     inString.size()) // The flags are none for the moment.
     <=0 )//this closing bracket has come still untouched from J Raki ;-)
    return false;
#endif
  
#ifdef _DEBUG
  cout << "END:Sending a message... " << endl << flush; 
#endif 


  waitWriteStream(inSocket);

  cout << "Message successfully sent!"
       << endl;

  return true;
}

void waitExceptionStream

(

int

inExceptioningSocket

)

Definition at line 176 of file HomeMadeServer.cc.

                                                  {
  
  fd_set lStreamsToWaitFor;
  FD_ZERO(&lStreamsToWaitFor);
  FD_SET(inExceptioningSocket,&lStreamsToWaitFor);
  
  timeval lWaitingTime;
  lWaitingTime.tv_sec=5;
  lWaitingTime.tv_usec=0;

  //cout << endl << "READwaiting" <<endl<< flush;
  
  while(!select(inExceptioningSocket+1,
    &lStreamsToWaitFor,
    0,
    0,
    &lWaitingTime));
  cout << "Exc arrived" << flush << endl;
}

void waitReadStream

(

int

inReadingSocket

)

Definition at line 156 of file HomeMadeServer.cc.

Referenced by asyncReadChar(), main(), and processMessage().

                                        {
  
  fd_set lStreamsToWaitFor;
  FD_ZERO(&lStreamsToWaitFor);
  FD_SET(inReadingSocket,&lStreamsToWaitFor);
  
  timeval lWaitingTime;
  lWaitingTime.tv_sec=5;
  lWaitingTime.tv_usec=0;

  //cout << endl << "READwaiting" <<endl<< flush;
  
  while(!select(inReadingSocket+1,
    &lStreamsToWaitFor,
    0,
    0,
    &lWaitingTime));
  //cout << "endwaiting" << flush << endl;
}

void waitWriteStream

(

int

inWritingSocket

)

Definition at line 131 of file HomeMadeServer.cc.

Referenced by sendMessage().

                                         {
  

  fd_set lStreamsToWaitFor;
  FD_ZERO(&lStreamsToWaitFor);
  FD_SET(inWritingSocket,&lStreamsToWaitFor);
  
  timeval lWaitingTime;
  lWaitingTime.tv_sec=5;
  lWaitingTime.tv_usec=0;

  int lCount=0;
  cout << "waiting" << flush;
  
  while(!select(inWritingSocket+1,
    0,
    &lStreamsToWaitFor,
    0,
    &lWaitingTime))lCount++;

  cout << "endwaiting" 
       << lCount 
       << flush 
       << endl;
}

---

Variable Documentation

TID gID

Definition at line 78 of file HomeMadeServer.cc.

long PORT = 12789

Definition at line 80 of file HomeMadeServer.cc.

Referenced by main().