test_many_cromp.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_many_cromp                                                   *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Sees how a cromp server does with a large number of connections.         *
*                                                                             *
*******************************************************************************
* Copyright (c) 2002-$now By Author.  This program 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.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/
 
#include "crompish_pax.h"
 
#include <mathematics/chaos.h>
#include <basis/astring.h>
 
#include <application/application_shell.h>
#include <application/command_line.h>
#include <application/hoople_main.h>
#include <structures/amorph.h>
#include <cromp/cromp_client.h>
#include <octopus/entity_defs.h>
#include <octopus/infoton.h>
#include <loggers/console_logger.h>
#include <loggers/critical_events.h>
#include <loggers/file_logger.h>
#include <loggers/program_wide_logger.h>
#include <sockets/internet_address.h>
#include <structures/static_memory_gremlin.h>
#include <timely/time_control.h>
#include <unit_test/unit_base.h>
 
#include <stdio.h>
 
using namespace application;
using namespace basis;
using namespace configuration;
using namespace cromp;
using namespace mathematics;
using namespace filesystem;
using namespace loggers;
using namespace octopi;
using namespace processes;
using namespace sockets;
using namespace structures;
using namespace textual;
using namespace timely;
using namespace unit_test;
 
#define DEBUG_TESTER
  // uncomment for noisier version.
 
const int REPORTING_INTERVAL = 20 * SECOND_ms;
  // how frequently we tell about bad crompers.
 
#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger::get(), astring(s))
#define BASE_LOG(s) EMERGENCY_LOG(program_wide_logger::get(), astring(s))
 
class many_cromp_tester : virtual public unit_base, virtual public application_shell
{
public:
  many_cromp_tester();
  ~many_cromp_tester();
 
  virtual int execute();
 
  DEFINE_CLASS_NAME("many_cromp_tester");
 
private:
  amorph<cromp_client> _uplinks;  // a list of cromp clients.
  bool _encryption;  // true if we're encrypting.
  int _count;  // number of cromps.
};
 
 
many_cromp_tester::many_cromp_tester()
: application_shell(),
  _uplinks(),
  _encryption(false),
  _count(1)
{
  FUNCDEF("constructor");
  LOG("");
  LOG("");
 
  internet_address server_loc;
 
  command_line args(application::_global_argc, application::_global_argv);
//LOG(a_sprintf("argc is %d and first is %s", application::_global_argc, application::_global_argv[0]));
 
  // check for a port on the command line.
  astring port_text;
  int port = 5678;
  if (args.get_value("port", port_text, false)) {
    LOG(astring("using port: ") + port_text);
    port = port_text.convert(5678);
  }
  server_loc.port = port;
 
  astring count_text;
  if (args.get_value("count", count_text, false)) {
    LOG(astring("using count: ") + count_text);
    _count = count_text.convert(_count);
  }
 
//hmmm: normalize host so this can take either name or IP.
 
  int indy = 0;
  if (args.find("encrypt", indy, false)
      || (args.find('e', indy, false)) ) {
    // they're saying that we should encrypt the communication.
    _encryption = true;
  }
 
  // check for a hostname on the command line.
  astring hostname("local");
  astring host_temp;
  if (args.get_value("host", host_temp, false)) {
    LOG(astring("using host: ") + host_temp);
    hostname = host_temp;
  }
LOG(astring("using host: ") + hostname);
  strcpy(server_loc.hostname, hostname.s());
 
LOG(astring("opening at ") + server_loc.text_form());
 
LOG(a_sprintf("count of %d cromps will be created.", _count));
 
  for (int i = 0; i < _count; i++) {
LOG(a_sprintf("%d. A", i));
    cromp_client *uplink = new cromp_client(server_loc);
LOG(a_sprintf("%d. B", i));
    uplink->add_tentacle(new bubbles_tentacle(false));
LOG(a_sprintf("%d. C", i));
    _uplinks.append(uplink);
  }
 
}
 
many_cromp_tester::~many_cromp_tester()
{
}
 
int many_cromp_tester::execute()
{
  FUNCDEF("execute");
 
  if (_encryption) {
    for (int i = 0; i < _uplinks.elements(); i++) {
      _uplinks.borrow(i)->enable_encryption();
    }
  }
 
  for (int i = 0; i < _uplinks.elements(); i++) {
    outcome ret = _uplinks.borrow(i)->connect();
    if (ret != cromp_client::OKAY) {
      deadly_error(class_name(), func, astring("connection failed with error: ")
          + cromp_client::outcome_name(ret));
    }
  }
 
time_stamp when_to_leave(10 * HOUR_ms);
 
  time_stamp next_report(REPORTING_INTERVAL);
 
  while (time_stamp() < when_to_leave) {
    int unconnected = 0;
    for (int i = 0; i < _uplinks.elements(); i++) {
      if (!_uplinks.borrow(i)->connected())
        unconnected++;
    }
 
    if (time_stamp() > next_report) {
      int connected = _uplinks.elements() - unconnected;
      LOG(a_sprintf("[ %d connected and %d did not ]", connected, unconnected));
      next_report.reset(REPORTING_INTERVAL);
    }
 
//do something with uplinks.
 
    time_control::sleep_ms(100);
  }
 
 
  BASE_LOG("many cromp_client:: works for those functions tested.");
 
  return 0;
}
 
 
HOOPLE_MAIN(many_cromp_tester, )