---

server.C

Go to the documentation of this file.

// $Id: server.C,v 1.1.1.1 2002/03/24 12:37:02 dvermeir Exp $
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <ctype.h>
#include <dvutil/props.h>
#include <dvutil/tostring.h>
#include <dvutil/file.h>
#include <dvutil/logstream.h>

#include "index.h"
#include "query.h"
#include "server.h"

using namespace Dv;

// This functions attempts to read a line of at most max_size chars.
// It should behave like getline(istream&,string&) except that it
// refuses to read more than max_size characters.
istream&
getmaxline(istream& is, string& line, string::size_type max_size) {
if (is) {
  char* buf = new char[max_size+2];
  is.getline(buf,max_size+1,'\n');
  line = buf;
  delete buf;
  }
return is;
}

Server::Server(const string& conf_fn) throw (runtime_error):
 config_fn_(conf_fn), max_cmd_(2048), log_(0) {
ifstream ifs(config_fn().c_str());
if (!ifs)
  throw runtime_error(config_fn() + ": cannot open");
Util::Props     config(ifs);

port_ = config["portnr"];
index_fn_ = config["index"];
wordlength_ = config["wordlength"];
ignore_fn_ = config["ignore"];
log_fn_ = config["logfile"];
if (config("maxcmd"))
  max_cmd_ = config["maxcmd"];

log_ = new Dv::Util::logstream(log_fn(), index_fn() );
if (!*log_)
  throw runtime_error(log_fn() + ": cannot open");

// Build index structure.
index_ = new Index(wordlength());

// Get words to be ignored and add to index.
ifstream ignore_is(ignore_fn().c_str());
if (!ignore_is)
  throw runtime_error(ignore_fn() + ": cannot open");
index().ignore(ignore_is);

// Read index structure from file, if it exists and can be read.
ifstream index_is(index_fn().c_str());
if (index_is)
  index_is >> index();
}

Server::~Server() {
delete log_;
delete index_;
}

bool
Server::ok_to_index(const string& path, ostream& err) const {
try {
  Util::File f(path);
  f.expand();

  if (!f.exists()) {
    err << error() << path << ": does not exist";
    return false;
    }
  if (f.type() != Util::File::REGULAR) {
    err << error() << path << ": not a regular file";
    return false;
    }
  ifstream ifs(path.c_str());
  if (!ifs) {
    err << error() << path << ": cannot open for reading";
    return false;
    }
  for (size_t i=0; (i<100); ++i) {
    char c(ifs.get());
    if (c==EOF)
      break;
    if (isprint(c) || isspace(c)) {
      }
    else {
      err << error() << path << ": not a text file";
      return false;
      }
    }
  }
catch (...) {
  return false;
  }
return true;
}


bool
Server::serve(iostream& ios) {
string line;
while (getmaxline(ios, line, max_cmd())) {
  if (line.size() > max_cmd() ) {
    log() << error() << "command too long, max = " << max_cmd() << endl;
    return true;
    }

  if (line.size() == 0) {
    log() << error() << "empty command" << endl;
    return true;
    }

  log() << "CMD: " << line << endl;
  
  istringstream iss(line);

  string command;
  iss >> command;

  if (command == "stop") {
    log() << "STOP" << endl;
    ios << ok() << endl;
    return false;
    }
  else if (command == "save") {
    log() << "SAVE" << endl;
    ofstream index_os(index_fn().c_str());
    if (index_os) {
      index_os << index();
      index_os.close();
          log() << ok() << endl;
          ios << ok() << endl;
          }
    else {
      log() << "ERROR SAVING" << endl;
      ios << error() << "cannot save to \"" << index_fn() << "\"" << endl;
      }
    }
  else if (command == "add") {
    string path;
    iss >> path;
    ostringstream oss;
    if (ok_to_index(path, oss)) {
      Util::File f(path); // Should succeed.
      path = f.expand().str();
      // Check whether path is not already indexed.
      time_t ti(index().date(path)); // 0 if not found.
      time_t tn(f.last_modified());
      if (tn>ti) { // File modified since it was last indexed.
        ifstream ifs(f.path());
        index().insert(f.str(),ifs);
        }
      log() << ok() << endl;
      ios << ok() << endl;
      }
    else {
      log() << oss.str() << endl;
      ios << oss.str() << endl;
      }
    }
  else if (command == "query") {
    string qs; // Query text.
    getline(iss,qs);
    log() << "QUERY " << qs << endl;
    try {
      Query q(index(), qs);
      const Index::Files& r(q.exec());
      log() << "ANSWER: " << r.size() << " FILES" << endl;
      for (Index::Files::const_iterator f=r.begin(); f!=r.end(); ++f) 
        ios << **f << endl;
      // end with empty line
      ios << endl;
      }
    catch (exception& e) {
      log() << error() << e.what() << endl;
      }
    }
  else {
    ios << error() << "unknown command: \"" << command << "\""  << endl;
    log() << error() << "unknown command: \"" << command << "\""  << endl;
    }
  }
return true;
}

---

textindexer-0.2

[27 March, 2002]