source: tags/0.5/stoposclient.cpp @ 9

#include <iostream>
#include <vector>
#include <stdlib.h>
#include <getopt.h>
#include <fstream>
#include "wrequest.h"
#include "shellenv.h"
#include "stopos.h"

struct returnvalue
{
  std::string msg;
  std::string key;
  std::string comm;
  std::string value;

  void parse(std::string &s)
  {
    // we expect somewhere in the output of the server a line like
    // STOPOS:/OK/123/beautiful
    // OK        -> msg
    // 123       -> key
    // 1         -> comm
    // beautiful -> value
    //
    // OK, 123 and beautiful are hex coded
    this->msg   = "";
    this->key   = "";
    this->comm  = "0";
    this->value = "";

    size_t p = s.find("STOPOS:");
    if (p == s.npos)
      return;

    size_t q = s.find('\n',p+1);
    std::string l = s.substr(p,q-p);
    std::vector <std::string> v;

    split(v,l,outsep);
    std::cerr << "WTD:"<<__LINE__<<":"<<l<<std::endl;
    for (unsigned int i=1; i<v.size(); i++)
    {
      switch (i)
      {
        case 1: this->msg   = zhextostr(v[i]); break;
        case 2: this->key   = zhextostr(v[i]); break;
        case 3: this->comm  = zhextostr(v[i]); break;
        case 4: this->value = zhextostr(v[i]); break;
      }
    }
  }
};

void usage()
{
  std::cerr << "Usage:" << std::endl;

  std::cerr << program_name << " -h,--help : this message" << std::endl;
  std::cerr << program_name << " -c,--create [-p,--pool POOL] [-i,--input   INPUTFILE]" << std::endl;
  std::cerr << program_name << " -n,--next   [-p,--pool POOL] [-d --lockdir LOCKDIR  ] [-k,--key KEY] [-m,--max MAX]" << std::endl;
  std::cerr << program_name << " -r,--ready  [-p,--pool POOL] [-d --lockdir LOCKDIR  ] [-k,--key KEY]" << std::endl;
  std::cerr << program_name << " -s,--stats  [-p,--pool POOL] [-d --lockdir LOCKDIR  ]" << std::endl;
  std::cerr << program_name << " -u,--unhandled  [-p,--pool POOL] [-d --lockdir LOCKDIR  ]" << std::endl;
  std::cerr << program_name << " -v,--version" << std::endl;
  std::cerr << "Defaults:" << std::endl;
  std::cerr << "  POOL     : " << "d.defpath_pool" << std::endl;
  std::cerr << "  LOCKDIR  : " << "d.defpath_lockdir"  << std::endl;
  std::cerr << "  MAX      : " << "1" << std::endl;
  std::cerr << "  INPUTFILE: " << "d.definputfilename";
  //if ("d.definputfilename" == "-")
   // std::cerr << " (standard input)";
  std::cerr << std::endl;
}

int handle_add(wrequest &w,const std::string &fname,returnvalue &r)
{

  int rc;
  std::ifstream inp;
  std::istream *pinp;
  if(fname == "")  // read from stdin
    pinp = &std::cin;
  else
  {
    inp.open(fname.c_str());
    if (!inp.is_open())
    {
      r.msg = "ERROR: Cannot open '"+fname+"'";
      return 1;
    }
    pinp = &inp;
  }
  std::string line;
  size_t n = 0;
  w.set_command("add");
  std::string body,header;
  while (getline(*pinp,line))
  {
    std::cerr << "WTD:" << __FILE__<<":"<<__LINE__ << "line:'" << line <<"'" << std::endl;
    w.set_value(line);
    rc = w.send_message(body,header);
    std::cerr << "WTD:" << __FILE__<<":"<<__LINE__ << "body" << std::endl << body << std::endl << "/body\n";
    if (rc != 0)
    {
      r.msg = "ERROR: Cannot connect to server";
      return 1;
    }
    r.parse(body);
    if (r.msg != "OK")
      break;
    n++;
  }
  std::cerr << program_name << ": Number of lines added = "<<n<<std::endl;
  if (r.msg != "OK")
    return 1;
  return 0;
}

int main(int argc, char*argv[])
{
  std::cerr << "start stoposclient ...\n";
  wrequest w;
  
  int rc;

  rc = w.read_config();
  if (rc != 0 || w.get_config().size() != w.config_size)
  {
    std::cerr << "No valid config file found, creating it ..." << std::endl;
    rc = w.write_config();
    if (rc != 0)
    {
      std::cerr << "Cannot write config file, exiting." << std::endl;
      return 1;
    }
  }

  bool addflag=0;
  std::string inputfilename;
  std::vector <std::string> parms;

  static struct option long_options[] =
  {
    {"help",     0, 0, 'h'},
    {"pool",     1, 0, 'p'},
    {"file",     1, 0, 'f'},
    {"version",  0, 0, 'v'},
    {"multi",    0, 0, 'm'},
    {0,          0, 0, 0}
  };

  // determine name of pool, in case it is not set on commandline

  std::string pool = default_pool;
  std::string p = envtostr("STOPOS_POOL");

  if (p != "")
    pool = p;

  if (trim(w.get_pool()) != "")
    pool = w.get_pool();

  while(1)
  {
    int c = getopt_long(argc,argv,"-hp:f:vm",long_options,0);
    if (c == -1)
    {
      if (optind < argc)  // unexpected extra argument
      {
        std::cerr << program_name << ": Unexpected argument:" << argv[optind] << std::endl;
        return 1;
      }
      break;
    }
    if ( c == '?' || c == ':' )
    {
      std::cerr << "Invalid parameter, try "<< argv[0]<<" --help " <<std::endl;
      return 1;
    }
    switch(c)
    {
      case 'h':
        usage();
        return 0;
        break;
      case 'p':
        pool = optarg;
        break;
      case 'f':
        inputfilename = optarg;
        break;
      case 'v':
        std::cerr << program_version << std::endl;
        break;
      case 'm':
        w.set_multi("yes");
        break;
      case 1:
        parms.push_back(optarg);
    }
  }

  std::cerr << "WTD:" << __LINE__ << ":POOL:" << pool <<std::endl;
  w.set_pool(pool);
  w.set_serverurl("http://localhost:5050/cgi-bin/stoposserver/");
  std::string  prot;
  prot = "gdbm";
  prot = "files";
  prot = "flat";
  prot = "mysql";
  w.set_protocol(prot);
  w.set_whoami(envtostr("USER"));

  rc = 0;
  returnvalue r;

  std::string command = parms[0];

  if(command == "create")
  {
    w.set_command("create");
  }
  else if(command == "purge")
  {
    w.set_command("purge");
  }
  else if(command == "next")
  {
    w.set_command("next");
  }
  else if(command == "remove")
  {
    w.set_command("remove");
      std::cerr << "WTD:" << __LINE__ << "VALUE:" << w.get_value()<<":" <<std::endl;
    if (parms.size() < 2)
    {
      std::string a=envtostr("STOPOS_KEY");
      if (a == "")
      {
        std::cerr << program_name << ": No key found, exit.\n";
        return 1;
      }
      w.set_value(a);
      std::cerr << "WTD:" << __LINE__ << "VALUE:" << w.get_value() <<std::endl;
    }
    else
      w.set_value(parms[1]);
  }
  else if(command == "status")
  {
    std::cerr << program_name << ": status not implemented yet, exit.\n";
    rc = 1;
  }
  else if(command == "dump")
  {
    std::cerr << program_name << ": dump not implemented yet, exit.\n";
    rc = 1;
  }
  else if(command == "add")
  {
    addflag = 1;
  }
  else
  {
    std::cerr << "Invalid command: '"<<command<<"'"<<std::endl;
  }

  if(addflag)
  {
    rc |= handle_add(w,inputfilename,r);
  }
  else
  {
    std::string body,header;
    rc = w.send_message(body,header);

    std::cerr << "WTD: rc:" << rc << std::endl;
    std::cerr << "WTD: header:" <<std::endl <<header << std::endl;
    std::cerr << "WTD: body:" <<std::endl <<body << std::endl;

    if (rc != 0)
      r.msg = "ERROR: Cannot connect to server";
    else
      r.parse(body);
  }

  int shelltype;

  char *shell = getenv("SHELL");
  std::string sh;
  if (shell == 0)
    sh = "bash";
  else
    sh = shell;

  if (sh.find("csh") != sh.npos)
    shelltype=SHELL_CSH;
  else
    shelltype = SHELL_SH;

  std::cout << shellenv(r.msg,"STOPOS_RC",shelltype);
  std::cout << shellenv(r.key,"STOPOS_KEY",shelltype);
  std::cout << shellenv(r.comm,"STOPOS_COMMITTED",shelltype);
  std::cout << shellenv(r.value,"STOPOS_VALUE",shelltype);

  if (r.msg != "OK")
  {
    std::cerr << program_name<<": "<<r.msg << std::endl;
    rc = 1;
  }

  std::cerr << "WTD: all is well that ends well\n";
  return rc;
}