basic_log_test.cpp

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

#include "Basic_Log_Test.h"

#include "orbsvcs/Time_Utilities.h"

#include "tao/debug.h"

#include "ace/Get_Opt.h"
#include "ace/Log_Msg.h"
#include "ace/SString.h"
#include "ace/OS_NS_stdio.h"


ACE_RCSID (Basic_Log_Test,
           Basic_Log_Test,
           "Basic_Log_Test.cpp,v 1.8 2003/11/01 11:15:10 dhinton Exp")


const char* BasicLog_Test::basic_log_factory_name_= "BasicLogFactory";
const char* BasicLog_Test::naming_sevice_name_ = "NameService";


BasicLog_Test::BasicLog_Test(void)
  : logServiceIor_ (0)
{
}

BasicLog_Test::~BasicLog_Test (void)
{
  this->destroy_log ();
}

int
BasicLog_Test::init (int argc, char *argv[])
{
  this->argc_ = argc;
  this->argv_ = argv;

  ACE_DECLARE_NEW_CORBA_ENV;
  ACE_TRY
    {
      // Initialize the ORB
      orb_ = CORBA::ORB_init (argc,
                              argv,
                              "internet" ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

      if (TAO_debug_level > 0)
        ACE_DEBUG ((LM_DEBUG,
                    "\nOrb initialized successfully\n"));

      // Parse command line and verify parameters.
      if (this->parse_args () == -1)
        return -1;

      // Initialize the factory
      int init_result = this->init_factory (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;

      if (init_result != 0)
        ACE_ERROR_RETURN ((LM_ERROR,
                           " (%P|%t) Unable to initialize naming"
                           "services.\n"),
                          -1);
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "init");
      return -1;
    }
  ACE_ENDTRY;

  ACE_RETURN(0);

}

int
BasicLog_Test::init_factory (ACE_ENV_SINGLE_ARG_DECL)
{

  // Assumpting INS for finding LogServie

  //CORBA::Object_var logging_obj = orb_->resolve_initial_references ("BasicLogFactory",
  //                                                         ACE_TRY_ENV);

  this->resolve_naming_service (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  this->resolve_basic_factory (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  /*
  if (TAO_debug_level > 0)
    ACE_DEBUG ((LM_DEBUG,
                "\nLoggingService resolved\n"));

  if (CORBA::is_nil (logging_obj.in ()))
    ACE_ERROR_RETURN ((LM_ERROR,
                       "LogService resolved to nil object\n"),
                      -1);
  if (TAO_debug_level > 0)
    ACE_DEBUG ((LM_DEBUG,
                "\nLogService resolved\n"));

  // Narrow the factory and check the success
  factory_ =
    DsLogAdmin::BasicLogFactory::_narrow (logging_obj.in () ACE_ENV_ARG_PARAMETER);

  if (TAO_debug_level > 0)
    ACE_DEBUG ((LM_DEBUG,
                "\nFactory narrowed\n"));
  if (CORBA::is_nil (factory_.in ()))
    ACE_ERROR_RETURN ((LM_ERROR,
                       "narrow returned nil"n"),
                      -1);
  if (TAO_debug_level > 0)
    ACE_DEBUG ((LM_DEBUG,
                "\nLogger_Factory narrowed\n"));
  */
  // If debugging, get the factory's IOR
  CORBA::String_var str =
    orb_->object_to_string (basicLog_.in()
                            ACE_ENV_ARG_PARAMETER); //Init the Client
  ACE_CHECK_RETURN (-1);

  if (TAO_debug_level > 0)
    ACE_DEBUG ((LM_DEBUG,
                "The logger IOR is <%s>\n",
                str.in ()));

  return 0;
}

int
BasicLog_Test::test_CreateLog (CORBA::ULongLong maxSize)
{

  ACE_TRY_NEW_ENV
    {
      DsLogAdmin::LogId id;
      basicLog_ = factory_->create(DsLogAdmin::wrap, maxSize, id);
      // @@ Krish, never use != 0 to compare a NIL object reference!!!
      ACE_ASSERT (!CORBA::is_nil (basicLog_.in ()));
      ACE_TRY_CHECK;
      ACE_DEBUG ((LM_DEBUG,
                  "The logger id is %d\n",
                  id));
    }
/*  ACE_CATCH(DsLogAdmin::NoResources, resourceX)
    {
      ACE_ERROR_RETURN ((LM_ERROR,
                         "no resources creating basic log.\n"),
                        -1);
    }
*/
  ACE_CATCH(DsLogAdmin::InvalidThreshold, threshold)
    {
      ACE_ERROR_RETURN ((LM_ERROR,
                         "invalid threshold creating basic log.\n"),
                        -1);
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION(ACE_ANY_EXCEPTION,"test_CreateLog");
      ACE_ERROR_RETURN ((LM_ERROR,
                         "Caught exception creating log.\n"),
                        -1);
    }
  ACE_ENDTRY;

  ACE_RETURN(0);
}

int
BasicLog_Test::test_LogAction ()
{
  ACE_TRY_NEW_ENV
    {
      DsLogAdmin::LogId id = basicLog_->id ();

      ACE_DEBUG ((LM_DEBUG, "The log's id is %d\n", id));

      basicLog_->set_log_full_action (DsLogAdmin::halt);

      DsLogAdmin::LogFullActionType logFullAction =
        basicLog_->get_log_full_action ();

      if (logFullAction != DsLogAdmin::halt)
        {
          ACE_ERROR_RETURN((LM_ERROR,
                            "Setting log full action to halt failed\n"),-1);
        }

      ACE_DEBUG ((LM_DEBUG,
                 "The log's full action successfully set to halt\n"));

#ifndef ACE_LACKS_LONGLONG_T
      ACE_DEBUG ((LM_INFO,
                 "The current size %Q, max size %Q\n",
                 basicLog_->get_current_size (),
                 basicLog_->get_max_size()));
#else
      ACE_DEBUG ((LM_DEBUG,
                 "The current size %u , max size %u\n",
                 basicLog_->get_current_size().lo (),
                 basicLog_->get_max_size().lo ()));
#endif

      // make sure that it is full and when writing
      this->write_records (0 ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

      ACE_DEBUG ((LM_DEBUG,
                  "Wrote records instead should have thrown exception"));

      basicLog_->set_log_full_action (DsLogAdmin::wrap);
      ACE_ERROR_RETURN((LM_ERROR,"Testing log action halt failed\n"),-1);
    }
  ACE_CATCH(DsLogAdmin::LogFull, xLogFull)
    {
      ACE_DEBUG ((LM_DEBUG,"Correctly caught exception LogFull\n"));

      CORBA::ULongLong nrecords = basicLog_->get_n_records ();

      ACE_DEBUG ((LM_ERROR,
                  "The number of records written was %d\n",
                  ACE_U64_TO_U32 (nrecords)));

      DsLogAdmin::AvailabilityStatus logStatus =
        basicLog_->get_availability_status ();

      if (!logStatus.log_full)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "Failed the log's get_availability_status.\n"),
                          -1);

      ACE_DEBUG ((LM_DEBUG,
                 "Log's availability status correctly set to log_full\n"));

      basicLog_->set_log_full_action (DsLogAdmin::wrap);
      DsLogAdmin::LogFullActionType logFullAction =
        basicLog_->get_log_full_action();

      if (logFullAction != DsLogAdmin::wrap)
        ACE_ERROR_RETURN((LM_ERROR,
                          "Setting log full action to wrap failed\n"),-1);

      ACE_TRY_EX (SECOND)
        {
          int i = this->write_records (0 ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK_EX (SECOND);

          ACE_DEBUG ((LM_DEBUG,"Test to wrap worked. %d written.\n",i));
        }
      ACE_CATCH (DsLogAdmin::LogFull, xLogFull)
        {
          ACE_DEBUG ((LM_ERROR,"Caught exception LogFull.  Fail testing wrapping of the log.\n"));
          return -1;
        }
      ACE_CATCHANY
        {
          ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "test_LogAction");
          return -1;
        }
      ACE_ENDTRY;
    }
  ACE_ENDTRY;

  return 0;
}
/*
int BasicLog_Test::display_records ()
{
  DsLogAdmin::Iterator_var iter_out;
  DsLogAdmin::RecordList_var rec_list =
    basicLog_->query ("TCL", "id > 0", iter_out);

  CORBA::ULong j = 0;
  for (; j < rec_list->length();++j)  //dhanvey added info
#ifndef ACE_LACKS_LONGLONG_T
   ACE_DEBUG ((LM_DEBUG,
               "id = %Q, time= %Q\n",
               rec_list[j].id, rec_list[j].time));
#else
   ACE_DEBUG ((LM_DEBUG,
               "id = %u, time= %u\n",
               rec_list[j].id.lo(), rec_list[j].time.lo()));
#endif

  return 0;

}
*/
int BasicLog_Test::write_records (CORBA::ULongLong numberOfRecords
                                  ACE_ENV_ARG_DECL_NOT_USED)
{
  CORBA::ULongLong numOfRecs = numberOfRecords;
  if (numOfRecs == 0)
    {
      numOfRecs = basicLog_->get_max_size();
    }

#ifndef ACE_LACKS_LONGLONG_T
  ACE_DEBUG ((LM_INFO,"B_test: Write_records: Max size in bytes %Q.\n", numOfRecs));
#else
  ACE_DEBUG ((LM_INFO,"B_test: Write_records: currentsize in bytes %u.\n", numOfRecs.lo()));
#endif

  int i = 0;
  CORBA::ULongLong l = 0;

  if (numOfRecs == 0)
  {
    for (;;)
    {
        DsLogAdmin::Anys record;
        record.length(1);
        ACE_CString str ("For the test of log "
                         "full action, writing test record, ");
        char number[32];
        ACE_OS::sprintf (number, "%d.", i);
        str += number;
        l += str.length ();
        // record owns internal os string
        ++i;
        CORBA::String_var t(str.c_str ());
        record[0] <<= t.in ();
        basicLog_->write_records(record);
    }
  }
  else
  {
    for(l = 0 ; l < numOfRecs ;)
    {
        DsLogAdmin::Anys record;
        record.length(1);
        ACE_CString str ("For the test of log "
                         "full action, writing test record, ");
        char number[32];
        ACE_OS::sprintf (number, "%d.", i);
        str += number;
        l += str.length ();
        // record owns internal os string
        ++i;
        CORBA::String_var t(str.c_str ());
        record[0] <<= t.in ();
        basicLog_->write_records(record);

      }
  }

#ifndef ACE_LACKS_LONGLONG_T
    ACE_DEBUG ((LM_INFO,"B_test: Write_records: currentsize in bytes %Q.\n",
               basicLog_->get_current_size()));
#else
    ACE_DEBUG ((LM_DEBUG,"B_test: Write_records: currentsize in bytes %u.\n",
               basicLog_->get_current_size().lo()));
#endif

//dhanvey
  CORBA::ULongLong nrecords = basicLog_->get_n_records();

  ACE_DEBUG ((LM_ERROR,"The number of records in log is %d\n", ACE_U64_TO_U32(nrecords)));

  ACE_RETURN(nrecords);
}

int
BasicLog_Test::test_adminState()
{
  ACE_DECLARE_NEW_CORBA_ENV;

  basicLog_->set_administrative_state(DsLogAdmin::locked);
  ACE_TRY
    {
      this->write_records(0 ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

      ACE_ERROR_RETURN((LM_ERROR,"Setting administrative state to lock failed.  DsLogAdmin::LogLocked not thrown.\n"),-1);

    }
  ACE_CATCH(DsLogAdmin::LogLocked, xLocked)
    {
      ACE_DEBUG ((LM_DEBUG,"Setting administrative state to lock succeeded.  DsLogAdmin::LogLocked was caught.\n"));
    }
  ACE_CATCHANY
    {
      basicLog_->set_administrative_state(DsLogAdmin::unlocked);
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "test_adminState");
      ACE_ERROR_RETURN((LM_ERROR,"Setting administrative state to lock failed. Exception throw.\n"),-1);
    }
  ACE_ENDTRY;

  basicLog_->set_administrative_state(DsLogAdmin::unlocked);
  ACE_TRY_EX(SECOND)
    {
      this->write_records(0 ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK_EX (SECOND);
      ACE_DEBUG ((LM_DEBUG,"Setting administrative state to succeeded.  DsLogAdmin::LogLocked not thrown.\n"));
      ACE_RETURN(0);