path: root/server/src/server.cc

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/***************************************************************************
 *            server.cc
 *
 *  Wed Aug 22 12:16:03 CEST 2007
 *  Copyright 2007 Bent Bisballe Nyeng
 *  deva@aasimon.org
 ****************************************************************************/

/*
 *  This file is part of Pracro.
 *
 *  Pracro 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 2 of the License, or
 *  (at your option) any later version.
 *
 *  Pracro 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 Pracro; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */
#include "server.h"

#include "tcpsocket.h"
#include <errno.h>

#include <stdlib.h>

// For fork
#include <sys/types.h>
#include <unistd.h>

#include "configuration.h"
#include "transaction.h"
#include "transactionparser.h"
#include "templateparser.h"
#include "queryhandler.h"
#include "queryparser.h"
#include "luaquerymapper.h"
#include "database.h"
#include "widgetgenerator.h"
#include "resumeparser.h"
#include "journal_commit.h"

static void connection(TCPSocket &socket)
{
  Transaction transaction;
  TransactionParser parser(socket, transaction);
  parser.parse();

  socket.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
  socket.write("<pracro version=\"1.0\">\n");

  Database db;

  //
  // Handle commits
  //
  if(transaction.commits.size() > 0) {
    Commits::iterator i = transaction.commits.begin();
    while(i != transaction.commits.end()) {
      Commit &commit = *i;

      /*
      Macro macro;
      MacroParser parser(commit.macro, macro);
      parser.parse();
      */

      
      Macro macro;
      macro.attributes["name"] = commit.macro;
      macro.attributes["version"] = "1.0";//commit.version;
      
      db.commit(transaction.user, transaction.cpr, macro, commit.fields);

      /*
      std::string resume = resume_parser(macro.format.c_str(), commit);

      std::string journal_commit_addr = config()->lookup("journal_commit_addr");
      int journal_commit_port = config()->lookup("journal_commit_port");

      journal_commit(transaction.cpr.c_str(), transaction.user.c_str(),
                     journal_commit_addr.c_str(), journal_commit_port,
                     resume.c_str(), resume.length());
      */
      i++;
    }
  }

  //
  // Handle requests
  //
  Requests::iterator i = transaction.requests.begin();
  while(i != transaction.requests.end()) {
    Request &request = *i;

    printf("Handling request - macro: %s, course: %s\n", request.macro.c_str(), request.course.c_str());

    // Read and parse the template file.
    TemplateParser tp(request.course);
    tp.parse();

    Template *templ = tp.getTemplate();

    // Send the queries to Pentominos (if any)
    TCPSocket s;
    s.connect("localhost", 11108);
    QueryHandler qh(&s, transaction.cpr);
    
    std::vector< Macro >::iterator mi = templ->course.macroes.begin();
    while(mi != templ->course.macroes.end()) {
      Macro &macro = (*mi);
      if(macro.attributes["name"] == request.macro) {
        std::vector< Query >::iterator qi = macro.queries.begin();
        while(qi != macro.queries.end()) {
          qh.addQuery(*qi);
          qi++;
        }
      }
      mi++;
    }
    std::string result = qh.exec();

    printf("Got result: [%s]\n", result.c_str());

    // Parse the result from the queries to pentominos
    QueryParser qp(result);
    qp.parse();

    // Map the results
    LUAQueryMapper lqm(qp.result);

    socket.write("  <course name=\"");
    socket.write(templ->course.attributes["name"]);
    socket.write("\">\n");

    // Generate the macro and return it to the client
    std::vector< Macro >::iterator mi2 = templ->course.macroes.begin();
    while(mi2 != templ->course.macroes.end()) {
      Macro &macro = (*mi2);

      socket.write("    <macro name=\"");
      socket.write(macro.attributes["name"]);
      socket.write("\">\n");

      if(macro.attributes["name"] == request.macro) {
        // Handle lua programs
        if(macro.luaprograms.size()) {
          socket.write("      <luaprograms>\n");

          std::vector< LUAProgram >::iterator lpi = macro.luaprograms.begin();
          while(lpi != macro.luaprograms.end()) {
            socket.write("        <luaprogram name=\"");
            socket.write(lpi->attributes["name"]);
            socket.write("\">\n");
            
            socket.write(lpi->attributes["lua"]);

            socket.write("\n        </luaprogram>\n");

            lpi++;
          }

          socket.write("      </luaprograms>\n");
        }
        
        widgetgenerator(socket, macro, lqm, db);
      }

      socket.write("    </macro>\n");

      mi2++;
    }

    socket.write("  </course>\n");

    i++;
  }

  socket.write("</pracro>\n");
}


void server()
{
  int PauseMode = 1;
  int port;
  try {
    port = config()->lookup("port");
  } catch( ... ) {
    fprintf(stderr, "Could not read port.");
    return;
  }

  TCPSocket *socket = NULL;
  
  try {
    socket = new TCPSocket();
    socket->listen(port);
  } catch (Exception &e) {
    fprintf(stderr, "Error during parsing:\n%s\n",
            e.what());
    delete socket;
    socket = NULL;
    return;
  }

  while(socket->connected()) {

    { // Reload if new port is assigned.
      int old_port = port;
      try {
        port = config()->lookup("port");
      } catch( ... ) {
        fprintf(stderr, "Could not read port.");
        return;
      }

      if(port != old_port) {
        // Start listening on the new port
        delete socket;
        socket = new TCPSocket();
        socket->listen(port);
        PauseMode = 0;
      }
    }

    TCPSocket child = socket->accept();
    if(child.connected()) {
      //socket->disconnect();
      connection(child);
      //delete socket;

      /*
      switch(fork()) {
      case -1: // error
        fprintf(stderr, "Could not fork: %s\n", strerror(errno));
        break;
        
      case 0: // child
        socket->disconnect();
        connection(child);
        delete socket;
        return;
        
      default: // parent
        child.disconnect();
        break;
      }
      */
    }
  }

  delete socket;
  fprintf(stderr, "Oups... dropped out of the main loop\n");
}

#ifdef TEST_SERVER

char request[] = 
  "<?xml version='1.0' encoding='UTF-8'?>\n"
  "<pracro cpr=\"2003791613\" version=\"1.0\">\n"
  "  <request macro=\"example2\" course=\"example2\"/>\n"
  "</pracro>\n";

int main()
{
  Configuration conf("../etc/pracrod.conf");
  initConfig(&conf);

  switch(fork()) {
  case -1: // error
    return 1;
    
  case 0: // child
    server();
    return 0;
    
  default: // parent
    {
      TCPSocket socket;
      int port = config()->lookup("port");
      socket.connect("localhost", port);
      
      socket.write(request);
      char buf[32];
      memset(buf, 0, sizeof(buf));
      while(socket.read(buf, 31)) {
        printf(buf); fflush(stdout);
        memset(buf, 0, sizeof(buf));
      }
    }
    return 0;
  }
  
  return 1;
}

#endif/*TEST_SERVER*/