cc_command.cpp

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

// CC_command.cpp,v 1.16 2003/11/04 05:21:33 dhinton Exp
// ============================================================================
//
// = LIBRARY
//    TAO/orbsvcs/tests
//
// = FILENAME
//    CC_command.cpp
//
// = DESCRIPTION
//      This is the command classes for the test of the concurrency service.
//
// = AUTHORS
//      Torben Worm <[e-mail]>
//
// ============================================================================

#include "CC_command.h"
#include "CC_test_utils.h"
#include "CC_naming_service.h"
#include "ace/ACE.h"
#include "ace/Process.h"
#include "orbsvcs/CosConcurrencyControlC.h"
#include "ace/OS_NS_stdio.h"

ACE_RCSID(Concurrency, CC_command, "CC_command.cpp,v 1.16 2003/11/04 05:21:33 dhinton Exp")

CC_Command::~CC_Command(void)
{
}

int CC_Command::execute()
{
  return 0;
}

CC_Command::CC_Command(void)
{
}

CosConcurrencyControl::LockSet_var
CC_Command::GetLockSet (const char *lock_set_name
                        ACE_ENV_ARG_DECL)
{
  CosConcurrencyControl::LockSet_var ccls_ret;

  ACE_TRY
    {
      if(ACE_OS::strcmp(lock_set_name, "")!=0)
        {
          CORBA::Object_var ccls_obj =
            CC_naming_service::Instance()->get_obj_from_name ("",
                                                              lock_set_name
                                                              ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;

          ccls_ret =
            CosConcurrencyControl::LockSet::_narrow (ccls_obj.in ()
                                                     ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
      else
        {
          // No lock set name was given. Use the global lock set.
          if(cc_lockset_.in()==0)
            {
              ACE_THROW_RETURN (CORBA::UNKNOWN (), 0);
            }
          else
            ccls_ret = cc_lockset_.in ();
        }
    }
  ACE_CATCHANY
    {
      ACE_RE_THROW;
    }
  ACE_ENDTRY;

  return ccls_ret;
}

CORBA::Exception *CC_Command::excep_ = 0;

CosConcurrencyControl::LockSet_var CC_Command::cc_lockset_(0);

CC_Start_Cmd::CC_Start_Cmd (const char *config_file_name)
  : cfg_name_ (ACE_OS::strdup (config_file_name))
{
  //  printf("CC_Start_Cmd::CC_Start_Cmd: config: %s\n", config_file_name);
}

CC_Start_Cmd::~CC_Start_Cmd()
{
  // cfg_name_ is allocated in the lexer with strdup
  if (cfg_name_)
    {
      ACE_OS::free(cfg_name_);
      cfg_name_ = 0;
    }
}

int CC_Start_Cmd::execute(void)
{
  if(excep_)
    {
      printf("Exception: %s\n", excep_->_rep_id ());
      delete excep_;
      excep_ = 0;
      return 0; // CC_FAIL
    }

  printf("Executing start command (script file: %s)\n", cfg_name_);

  char cmd_line[1024];
  int success = ACE_OS::sprintf(&cmd_line[0], "%s -c %s",
                                "./CC_client", cfg_name_);
  if(success>=1024 || success==-1)
    ACE_ERROR_RETURN((LM_ERROR, "Creation of process failed: %s\n",
                      cmd_line), 0);

  ACE_Process new_process;
  ACE_Process_Options options;
  options.command_line(cmd_line);

  if(new_process.spawn(options) == -1)
    {
      ACE_ERROR_RETURN((LM_ERROR, "Creation of process failed: %s\n",
                        cmd_line), 0);
    }
  return 1; // CC_SUCCESS
}

CC_CreateLockSet_Cmd::CC_CreateLockSet_Cmd (const char *lock_set_name)
  : name_ (ACE_OS::strdup (lock_set_name))
{
  //  printf("CC_CreateLockSet_Cmd::CC_CreateLockSet_Cmd: lock set: %s\n",
  //         lock_set_name);
}

CC_CreateLockSet_Cmd::~CC_CreateLockSet_Cmd()
{
  // name_ is allocated in the lexer with strdup
  if(name_)
    {
      ACE_OS::free(name_);
      name_ = 0;
    }
}

int CC_CreateLockSet_Cmd::execute(void)
{
  if(excep_)
    {
      printf("Exception: %s\n", excep_->_rep_id ());
      delete excep_;
      excep_ = 0;
      return 0; // CC_FAIL
    }

  printf("Executing create command (lock set: %s)\n", name_);

  ACE_DECLARE_NEW_CORBA_ENV;
  ACE_TRY
    {
      CosConcurrencyControl::LockSet_ptr lock_set =
        CC_TestUtils::create_lock_set();
      if(ACE_OS::strcmp(name_,"")!=0)// Do not bind an empty name
        {
          CC_naming_service::Instance()->bind_name(name_,
                                                   lock_set ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
      else
        {
          // We did not specify a name => the global lock set variable is set
          cc_lockset_ = lock_set;
        }
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "CC_CreateLockSet_Cmd::execute(void)");
    }
  ACE_ENDTRY;

  return 1; // CC_SUCCESS
}

CC_Lock_Cmd::CC_Lock_Cmd (const char *lock_set_name,
                          CosConcurrencyControl::lock_mode mode)
  : name_ (ACE_OS::strdup (lock_set_name)),
    mode_(mode)
{
  //  printf("CC_Lock_Cmd::CC_Lock_Cmd: lock set: %s, mode: %s\n",
  //         lock_set_name, CC_TestUtils::get_lock_mode_name(mode));
}

CC_Lock_Cmd::~CC_Lock_Cmd()
{
  ACE_OS::free (this->name_);
}

int CC_Lock_Cmd::execute(void)
{
  if(excep_)
    {
      printf("Exception: %s\n", excep_->_rep_id ());
      delete excep_;
      excep_ = 0;
      return 0; // CC_FAIL
    }

  printf("Executing lock command (lock set: %s, mode: %s)\n",
         name_, CC_TestUtils::get_lock_mode_name(mode_));

  ACE_DECLARE_NEW_CORBA_ENV;
  ACE_TRY
    {
      CosConcurrencyControl::LockSet_var ccls =
        GetLockSet(name_ ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
      ccls->lock (mode_
                  ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "CC_Lock_Cmd::execute(void)");
      return 0;
    }
  ACE_ENDTRY;
  return 1; // CC_SUCCESS
}

CC_UnLock_Cmd::CC_UnLock_Cmd (const char *lock_set_name,
                              CosConcurrencyControl::lock_mode mode)
  : name_ (ACE_OS::strdup (lock_set_name)),
    mode_ (mode)
{
  //  printf("CC_UnLock_Cmd::CC_UnLock_Cmd: lock set: %s, mode: %s\n",
  //         lock_set_name, CC_TestUtils::get_lock_mode_name(mode));
}

CC_UnLock_Cmd::~CC_UnLock_Cmd()
{
  ACE_OS::free (this->name_);
}

int CC_UnLock_Cmd::execute(void)
{
  if(excep_)
    {
      printf("Exception: %s\n", excep_->_rep_id ());
      delete excep_;
      excep_ = 0;
      return 0; // CC_FAIL
    }

  printf("Executing unlock command (lock set: %s, mode: %s)\n",
         name_, CC_TestUtils::get_lock_mode_name(mode_));

  ACE_DECLARE_NEW_CORBA_ENV;
  ACE_TRY
    {
      CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_ ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

      ccls->unlock (mode_
                    ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "CC_UnLock_Cmd::execute(void)");
      return 0;
    }
  ACE_ENDTRY;
  return 1; // CC_SUCCESS
}

CC_TryLock_Cmd::CC_TryLock_Cmd (const char *lock_set_name,
                                CosConcurrencyControl::lock_mode mode)
  : name_ (ACE_OS::strdup (lock_set_name)),
    mode_ (mode)
{
  //  printf("CC_TryLock_Cmd::CC_TryLock_Cmd: lock set: %s, mode %s\n",
  //         lock_set_name, CC_TestUtils::get_lock_mode_name(mode));
}

CC_TryLock_Cmd::~CC_TryLock_Cmd()
{
  ACE_OS::free (this->name_);
}

int CC_TryLock_Cmd::execute(void)
{
  if(excep_)
    {
      printf("Exception: %s\n", excep_->_rep_id ());
      delete excep_;
      excep_ = 0;
      return 0; // CC_FAIL
    }

  printf("Executing try_lock command (lock set: %s, mode: %s)\n",
         name_, CC_TestUtils::get_lock_mode_name(mode_));

  CORBA::Boolean lock_not_held;

  ACE_DECLARE_NEW_CORBA_ENV;
  ACE_TRY
    {
      CosConcurrencyControl::LockSet_var ccls = GetLockSet(name_ ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

      lock_not_held = ccls->try_lock (mode_
                                      ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

      if (lock_not_held)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "%s lock not held\n",
                      CC_TestUtils::get_lock_mode_name (mode_)));
        }
      else
        ACE_DEBUG ((LM_DEBUG,
                    "%s lock held\n",
                    CC_TestUtils::get_lock_mode_name (mode_)));
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "CC_TryLock_Cmd::execute(void)");
      return 0;
    }