source: tags/0.5/stoposserver.cpp @ 9

#include <iostream>
#include <stdlib.h>
#include <vector>
#include <string>
#include "stopos.h"
#include "wutils.h"
#include "stopos_pool.h"
#include "gdbm_pool.h"
#include "flatfile_pool.h"
#include "files_pool.h"
#include "mysql_pool.h"

void output(const std::string &return_message, const std::string &key,
             unsigned int committed, const std::string &return_value)
{
  std::cout << "STOPOS:"                 << outsep <<
               zstrtohex(return_message) << outsep <<
               zstrtohex(key)            << outsep <<
               zstrtohex(NumberToString(committed)) << outsep <<
               zstrtohex(return_value) << 
               std::endl;
}

void output(const std::string &msg)
{
  output(msg,"",0,"");
}
struct commandline
{
  std::string header;
  std::string prot;
  std::string id;
  std::string pool;
  std::string command;
  std::string multi;
  std::string value;
  std::string full_dbname;
  std::string return_value;
  stopos_pool *handler;

  int create_full_dbname(void)
  {
    if (this->prot == "gdbm" ||
        this->prot == "flat" ||
        this->prot == "files")
    {
      this->full_dbname = "/tmp/"              +
                          zstrtohex(this->id)   +
                          "/"                  +
                          zstrtohex(this->pool) +
                          "_"                  +
                          this->prot;
    }
    else if (this->prot == "mysql")
    {
      this->full_dbname = zstrtohex(this->id) +
                          "_"                +
                          zstrtohex(this->pool);
    }
    else
      return 1;

    this->handler->set_db_name(this->full_dbname);
    return 0;
  }

  int create_handler()
  {
    if (this->prot == "gdbm")
    {
      this->handler = new gdbm_pool();
    }
    if (this->prot == "flat")
    {
      this->handler = new flatfile_pool();
    }
    if (this->prot == "files")
    {
      this->handler = new files_pool();
    }
    if (this->prot == "mysql")
    {
      this->handler = new mysql_pool();
    }
    return 0;
  }

  int init()
  {
    int rc;
    rc = this->create_handler();
    if (rc != 0) 
      return rc;
    if (this->multi == "yes")
      this->handler->set_kvp(1);
    else
      this->handler->set_kvp(0);
    rc = this->create_full_dbname();
    return rc;
  }

  int create_db()
  {
    int rc = this->handler->create_db();
    return rc;
  }

  int purge_db()
  {
    int rc = this->handler->purge_db();
    return rc;
  }

  int add_line(std::string &key,std::string &r)
  {
    int rc;
    rc = this->handler->open_db();
    if (rc != 0)
    {
      r = "ERROR: cannot open pool "+this->pool;
      return rc;
    }

    rc = this->handler->add_line(this->value,key);
    if (rc != 0)
    {
      r = "ERROR: cannot write to pool "+this->pool;
      return rc;
    }
    return 0;
  }

  int get_line(std::string &key, unsigned int &comm, std::string &r)
  {
    int rc;
    rc = this->handler->open_db();
    if (rc != 0)
    {
      r = "ERROR: cannot open pool "+this->pool;
      return rc;
    }
    rc = this->handler->get_line(this->return_value, comm, key);
    std::cerr << "WTD:"<<__FILE__<<__LINE__<<":"<<this->return_value<<":"<<comm<<std::endl;
    return rc;
  }

  int remove_line(std::string & rkey,std::string &key, std::string &r)
  {
    int rc;
    rc = this->handler->open_db();
    if (rc != 0)
    {
      r = "ERROR: cannot open pool "+this->pool;
      return rc;
    }
    rkey = key;
    rc = this->handler->remove_line(key);
    std::cerr << "WTD:"<<__FILE__<<__LINE__<<":"<<rc<<std::endl;
    return rc;
  }

};

std::string sanitycheck(commandline &l)
{
  if (l.header != "stopos")
    return "invalid header";

  if (l.prot.find_first_of(' ') != l.prot.npos)
    return "no valid protocol given";

  if(l.id.find_first_of(' ') != l.id.npos)
    return "no valid id given";

  if(l.pool.find_first_of(' ') != l.pool.npos)
  {
    return "no valid pool given";
  }
  if(l.command.find_first_of(' ') != l.command.npos)
  {
    return "no valid command given";
  }
  return "";
}

int parsecom(commandline &l,std::string &line)
{
  std::vector <std::string> v;
  split(v,line,httpsep); 
                       
  for (unsigned int i =0; i<v.size(); i++)
  {
    std::cout <<"WTD:"<< i << ":[" << zhextostr(v[i]) << "]" << std::endl;
    switch(i)
    {
      case 0: l.header   = zhextostr(v[i]); break;
      case 1: l.prot     = zhextostr(v[i]); break;
      case 2: l.id       = zhextostr(v[i]); break;
      case 3: l.pool     = zhextostr(v[i]); break;
      case 4: l.command  = zhextostr(v[i]); break;
      case 5: l.multi    = zhextostr(v[i]); break;
      case 6: l.value    = zhextostr(v[i]); break;
    }
  }
  return 0;
}


int executecom(commandline &l)
{
  int rc;
  unsigned int committed = 0;

  std::string return_message;
  std::string key;
  rc = l.init();
  if (rc != 0)
  {
    output("ERROR: cannot initialize server software");
    return rc;
  }

  if (l.command == "create")
  {
    std::cerr << "WTD: execute:"<<l.command<<std::endl;
    std::cerr << "WTD: full:"<<l.full_dbname<<std::endl;
    std::cerr << "WTD: prot:"<<l.prot<<std::endl;

    rc = l.create_db();
    if (rc != 0)
      return_message = "ERROR: cannot create pool "+l.pool;
    std::cerr << "WTD: created! :"<<rc<<std::endl;
  }
  else if (l.command == "purge")
  {
    std::cerr << "WTD: execute:"<<l.command<<std::endl;
    rc = l.purge_db();
  }
  else if (l.command == "add")
  {
    std::cerr << "WTD: add:"<<l.command<<std::endl;
    rc = l.add_line(key,return_message);
    std::cerr << "WTD: added! :"<<rc<<":'"<<l.value<<"'"<<std::endl;
  }
  else if (l.command == "next")
  {
    std::cerr << "WTD: next:"<<l.command<<std::endl;
    rc = l.get_line(key, committed, return_message);
    std::cerr << "WTD: nexted! :"<<rc<<":"<<committed<<std::endl;
  }
  else if (l.command == "remove")
  {
    std::cerr << "WTD: ready:"<<l.command<<std::endl;
    rc = l.remove_line(key,l.value, return_message);
    std::cerr << "WTD: readyed! :"<<rc<<std::endl;
  }
  else rc = 1;
  if (rc == 0)
    return_message="OK";
  else
    if (return_message == "")
      return_message="ERROR";

  output(return_message, key, committed, l.return_value);
  return rc;
}

int main()
{
  int rc;
  std::cout << "Content-Type: text/plain\n\n";
  std::cout << "WTD: Dit is stoposserver\n";
  std::string line;
  line = envtostr("PATH_INFO");
  if (line.size() >0)
    if (line[0] == '/')
      line.erase(0,1);
  std::cout << "WTD: PATH_INFO '"<<line <<"'"<< std::endl;

  commandline l;
  parsecom(l,line);
  std::string msg = sanitycheck(l);
  if (msg != "")
  {
    output(msg);
    return 1;
  }
  rc = executecom(l);

  std::cout << "WTD: stoposserver done\n";
  return rc;
}