source: tags/0.58/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 count;
  std::string present;
  std::string present0;
  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->count     = "0";
    this->present   = "0";
    this->present0  = "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);
    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->count     = zhextostr(v[i]); break;
        case 5: this->present   = zhextostr(v[i]); break;
        case 6: this->present0  = zhextostr(v[i]); break;
        case 7: this->value     = zhextostr(v[i]); break;
      }
      // special case for key: if key == "", we try to take
      // it from the environment.
      if (trim(this->key) == "")
        this->key = envtostr("STOPOS_KEY");
    }
  }
};

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))
  {
    w.set_value(line);
    rc = w.send_message(body,header);
    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[])
{
  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'},
    {"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: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 << program_name << ": Invalid parameter, try "<< program_name<<" --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;
        return 0;
        break;
      case 'm':
        w.set_multi("yes");
        break;
      case 1:
        parms.push_back(optarg);
    }
  }

  w.set_pool(pool);
  w.set_serverurl("http://localhost:5050/cgi-bin/stoposserver/");
  std::string  prot;
  prot = "mysql";
  prot = "gdbm";
  prot = "files";
  prot = "flat";
  std::string protenv;
  protenv = envtostr("STOPOS_PROT");
  if (protenv.size() !=0)
    prot = protenv;
  w.set_protocol(prot);
  w.set_whoami(envtostr("USER"));

  rc = 0;
  returnvalue r;

  if (parms.size() == 0)
  {
    std::cerr << program_name << ": No command given." << std::endl;
    return 1;
  }

  std::string command = parms[0];

  // only the remove and add commands can accept an extra parameter
  //

  if (parms.size() >1)
    if (command !="remove" && command != "add")
    {
      std::cerr << program_name << ": Extraneous parameter:'"<<parms[1]<<"'."<<std::endl;
      return 1;
    }

  if(command == "create")
  {
    w.set_command("create");
  }
  else if(command == "purge")
  {
    w.set_command("purge");
  }
  else if(command == "status")
  {
    w.set_command("status");
  }
  else if(command == "next")
  {
    w.set_command("next");
  }
  else if(command == "dump")
  {
    w.set_command("dump");
  }
  else if(command == "pools")
  {
    w.set_command("pools");
  }
  else if(command == "remove")
  {
    w.set_command("remove");
    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);
    }
    else
      w.set_value(parms[1]);
  }
  else if(command == "add")
  {
    addflag = 1;
  }
  else
  {
    std::cerr << program_name << ": Invalid command: '"<<command<<"'"<<std::endl;
    return 1;
  }

  if(addflag)
  {
    if (parms.size() > 1)
      inputfilename = parms[1];
    rc |= handle_add(w,inputfilename,r);
  }
  else
  {
    std::string body,header;

    rc = w.send_message(body,header);

    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.count,    "STOPOS_COUNT",     shelltype);
  std::cout << shellenv(r.present,  "STOPOS_PRESENT",   shelltype);
  std::cout << shellenv(r.present0, "STOPOS_PRESENT0",  shelltype);
  std::cout << shellenv(r.value,    "STOPOS_VALUE",     shelltype);

  if (command == "status")
  {
    std::cerr << "lines added:           " << r.count    <<std::endl;
    std::cerr << "lines present:         " << r.present  <<std::endl;
    std::cerr << "lines never committed: " << r.present0 << std::endl;
  }
  else if (command == "pools")
  {
    std::cerr << r.value << std::endl;
  }
  if (r.msg != "OK")
  {
    std::cerr << program_name<<": "<<r.msg << std::endl;
    rc = 1;
  }

  return rc;
}