corbaorb.cc

编译工具

    return;
  }

  omniORB::logs(10, "Preparing to shutdown ORB.");

  pd_shutdown_in_progress = 1;

  if( wait_for_completion ) {
    actual_shutdown();
  }
  else {
    // If wait_for_completion is zero we need to pass this to another
    // thread. This is needed to support shutting down the orb from
    // a method invocation -- otherwise we would deadlock waiting for
    // the method invocation to complete.

    omniORB::logs(15, "Starting an ORB shutdown thread.");

    (new omni_thread(shutdown_thread_fn, (omniOrbORB*) this))->start();
  }
}

//////////////////////////////////////////////////////////////////////
////////////////////////  ORBAsyncInvoker  ///////////////////////////
//////////////////////////////////////////////////////////////////////

OMNI_NAMESPACE_BEGIN(omni)

ORBAsyncInvoker::~ORBAsyncInvoker()
{
  ASSERT_OMNI_TRACEDMUTEX_HELD(orb_lock, 1);
  OMNIORB_ASSERT(omniTaskLink::is_empty(invoker_dedicated_tq));
  OMNIORB_ASSERT(invoker_threads == 0);
}

int
ORBAsyncInvoker::work_pending()
{
  omni_tracedmutex_lock sync(orb_lock);

  return !omniTaskLink::is_empty(invoker_dedicated_tq);
}

void
ORBAsyncInvoker::perform(unsigned long secs, unsigned long nanosecs)
{
  orb_lock.lock();
  invoker_threads++;

  while (!invoker_shutting_down) {

    while (!invoker_shutting_down &&
	   omniTaskLink::is_empty(invoker_dedicated_tq)) {

      // Wait for a task to arrive
      if (secs || nanosecs) {
	if (invoker_signal.timedwait(secs, nanosecs) == 0) {
	  // timeout
	  invoker_threads--;
	  if (invoker_shutting_down) invoker_signal.signal();
	  orb_lock.unlock();
	  return;
	}
      }
      else {
	invoker_signal.wait();
      }
    }
    while (!omniTaskLink::is_empty(invoker_dedicated_tq)) {
      // Run all queued tasks
      omniTask* t = (omniTask*)invoker_dedicated_tq.next;
      t->deq();
      orb_lock.unlock();
      try {
	t->execute();
      }
      catch (...) {
	omniORB::logs(1, "ORBAsyncInvoker: Warning - unexpected "
		      "exception caught while executing a task.");
      }
      orb_lock.lock();
    }
  }
  OMNIORB_ASSERT(omniTaskLink::is_empty(invoker_dedicated_tq));

  invoker_threads--;
  if (invoker_shutting_down) invoker_signal.signal();
  orb_lock.unlock();
}

int
ORBAsyncInvoker::insert_dedicated(omniTask* t)
{
  OMNIORB_ASSERT(t->category() == omniTask::DedicatedThread);

  omni_tracedmutex_lock sync(orb_lock);
  t->enq(invoker_dedicated_tq);
  invoker_signal.signal();
  return 1;
}

int
ORBAsyncInvoker::cancel_dedicated(omniTask* t)
{
  OMNIORB_ASSERT(t->category() == omniTask::DedicatedThread);

  omni_tracedmutex_lock sync(orb_lock);

  omniTaskLink* l;

  for (l = invoker_dedicated_tq.next; l != &invoker_dedicated_tq; l= l->next) {
    if ((omniTask*)l == t) {
      l->deq();
      return 1;
    }
  }
  return 0;
}


OMNI_NAMESPACE_END(omni)


static void
shutdownAsyncInvoker()
{
  ASSERT_OMNI_TRACEDMUTEX_HELD(orb_lock, 1);
  invoker_shutting_down = 1;
  invoker_signal.broadcast();
}



//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////

static
CORBA::Boolean
isValidId(const char* id) {
  const char** p = orb_ids;
  while (*p) {
    if (strcmp(*p,id) == 0) return 1;
    p++;
  }
  return 0;
}

static
const char*
myOrbId() {
  return orb_ids[0];
}

OMNI_NAMESPACE_BEGIN(omni)

/////////////////////////////////////////////////////////////////////////////
//            Hooked initialiser                                           //
/////////////////////////////////////////////////////////////////////////////

static omnivector<omniInitialiser*>*& the_hooked_list()
{
  static omnivector<omniInitialiser*>* the_list = 0;
  if (!the_list) the_list = new omnivector<omniInitialiser*>;
  return the_list;
}

class omni_hooked_initialiser : public omniInitialiser {
public:
  void attach() {
    omnivector<omniInitialiser*>::iterator i    = the_hooked_list()->begin();
    omnivector<omniInitialiser*>::iterator last = the_hooked_list()->end();

    for (; i != last; i++) {
      (*i)->attach();
    }
  }

  void detach() {
    omnivector<omniInitialiser*>::iterator i    = the_hooked_list()->begin();
    omnivector<omniInitialiser*>::iterator last = the_hooked_list()->end();

    for (; i != last; i++) {
      (*i)->detach();
    }
  }

  virtual ~omni_hooked_initialiser() {
    omnivector<omniInitialiser*>*& the_list = the_hooked_list();
    delete the_list;
    the_list = 0;
  }
};

static omni_hooked_initialiser hinitialiser;
omniInitialiser& omni_hooked_initialiser_ = hinitialiser;

void
omniInitialiser::
install(omniInitialiser* init) {
  the_hooked_list()->push_back(init);
}


////////////////////////////////////////////////////////////////////////////
//             Configuration options                                      //
////////////////////////////////////////////////////////////////////////////
CORBA::Boolean   orbParameters::dumpConfiguration = 0;
//  Set to 1 to cause the ORB to dump the current set of configuration
//  parameters.
//
//  Valid values = 0 or 1

CORBA::Boolean   orbParameters::lcdMode = 0;
//  Set to 1 to enable 'Lowest Common Denominator' Mode.
//  This will disable various features of IIOP and GIOP which are
//  poorly supported by some ORBs, and disable warnings/errors when
//  certain types of erroneous message are received on the wire.
//
//  Valid values = 0 or 1


/////////////////////////////////////////////////////////////////////////////
//            Handlers for Configuration Options                           //
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
class helpHandler : public orbOptions::Handler {
public:

  helpHandler() :
    orbOptions::Handler("help",
			0,
			1,
			"-ORBhelp ",
			1) {}


  void visit(const char*,orbOptions::Source) throw (orbOptions::BadParam) {

    orbOptions::sequenceString_var usage;
    usage = orbOptions::singleton().usageArgv();

    omniORB::logger l;
    l << "Valid -ORB<options> are:\n";
    for (CORBA::ULong i = 0; i < usage->length(); i++)
      l << "  " << usage[i] << "\n";

  }

  void dump(orbOptions::sequenceString& result) {
    return;
  }
};

static helpHandler helpHandler_;

/////////////////////////////////////////////////////////////////////////////
class idHandler : public orbOptions::Handler {
public:

  idHandler() :
    orbOptions::Handler("id",
			"id = " ORB_ID_STRING,
			1,
			"-ORBid "ORB_ID_STRING" (standard option)") {}


  void visit(const char* value,orbOptions::Source) throw (orbOptions::BadParam) {

    if (!isValidId(value)) {
      throw orbOptions::BadParam(key(),value,"id is not "ORB_ID_STRING);
    }
    if( strcmp(value, myOrbId()) ) {
      if( omniORB::trace(1) ) {
	omniORB::logger l;
	l << "WARNING -- using ORBid " << value
	  << " (should be " << ORB_ID_STRING << ")." << "\n";
      }
    }
  }

  void dump(orbOptions::sequenceString& result) {
    orbOptions::addKVString(key(),ORB_ID_STRING,result);
  }
};

static idHandler idHandler_;

/////////////////////////////////////////////////////////////////////////////
class dumpConfigurationHandler : public orbOptions::Handler {
public:

  dumpConfigurationHandler() :
    orbOptions::Handler("dumpConfiguration",
			"dumpConfiguration = 0 or 1",
			1,
			"-ORBdumpConfiguration < 0 | 1 >") {}


  void visit(const char* value,orbOptions::Source) throw (orbOptions::BadParam) {

    CORBA::Boolean v;
    if (!orbOptions::getBoolean(value,v)) {
      throw orbOptions::BadParam(key(),value,
				 orbOptions::expect_boolean_msg);
    }
    orbParameters::dumpConfiguration = v;
  }

  void dump(orbOptions::sequenceString& result) {
    orbOptions::addKVBoolean(key(),orbParameters::dumpConfiguration,
			     result);
  }
};

static dumpConfigurationHandler dumpConfigurationHandler_;

/////////////////////////////////////////////////////////////////////////////
class lcdModeHandler : public orbOptions::Handler {
public:

  lcdModeHandler() :
    orbOptions::Handler("lcdMode",
			"lcdMode = 0 or 1",
			1,
			"-ORBlcdMode < 0 | 1 >") {}


  void visit(const char* value,orbOptions::Source) throw (orbOptions::BadParam) {

    CORBA::Boolean v;
    if (!orbOptions::getBoolean(value,v)) {
      throw orbOptions::BadParam(key(),value,
				 orbOptions::expect_boolean_msg);
    }
    orbParameters::lcdMode = v;
  }

  void dump(orbOptions::sequenceString& result) {
    orbOptions::addKVBoolean(key(),orbParameters::lcdMode,
			     result);
  }
};

static lcdModeHandler lcdModeHandler_;


/////////////////////////////////////////////////////////////////////////////
class principalHandler : public orbOptions::Handler {
public:

  principalHandler() :
    orbOptions::Handler("principal",
			"principal = <GIOP 1.0 principal string>",
			1,
			"-ORBprincipal <GIOP 1.0 principal string>") {}


  void visit(const char* value,orbOptions::Source) throw (orbOptions::BadParam) {
    CORBA::ULong l = strlen(value) + 1;
    omni::myPrincipalID.length(l);
    for (CORBA::ULong i = 0; i < l; i++)
      omni::myPrincipalID[i] = value[i];
  }

  void dump(orbOptions::sequenceString& result) {
    if (omni::myPrincipalID.length() == 0)
      orbOptions::addKVString(key(),"[Null]",result);
    else {
      CORBA::String_var s(CORBA::string_alloc(omni::myPrincipalID.length()+1));
      CORBA::ULong i;
      for (i=0; i<omni::myPrincipalID.length(); i++) {
	((char*)s)[i] = omni::myPrincipalID[i];
      }
      ((char*)s)[i] = '\0';
      orbOptions::addKVString(key(),s,result);
    }
  }
};

static principalHandler principalHandler_;

/////////////////////////////////////////////////////////////////////////////
class poa_iiop_portHandler : public orbOptions::Handler {
public:

#define POA_IIOP_IS_OBSOLETE "is now obsolete, use -ORBendpoint instead"

  poa_iiop_portHandler() :
    orbOptions::Handler("poa_iiop_port",0,1,0) {}

  void visit(const char* value,orbOptions::Source) throw (orbOptions::BadParam) {

    throw orbOptions::BadParam(key(),value,
			       "poa_iiop_port"POA_IIOP_IS_OBSOLETE);
  }

  void dump(orbOptions::sequenceString& result) {
    return;
  }
};

static poa_iiop_portHandler poa_iiop_portHandler_;

/////////////////////////////////////////////////////////////////////////////
class poa_iiop_name_portHandler : public orbOptions::Handler {
public:

  poa_iiop_name_portHandler() :
    orbOptions::Handler("poa_iiop_name_port",0,1,0) {}

  void visit(const char* value,orbOptions::Source) throw (orbOptions::BadParam) {
    throw orbOptions::BadParam(key(),value,
			       "poa_iiop_name_port"POA_IIOP_IS_OBSOLETE);
  }

  void dump(orbOptions::sequenceString& result) {
    return;
  }
};

static poa_iiop_name_portHandler poa_iiop_name_portHandler_;

/////////////////////////////////////////////////////////////////////////////
class configFileHandler : public orbOptions::Handler {
public:

  configFileHandler() :
    orbOptions::Handler("configFile",
			"configFile = <filename>",
			1,
			"-ORBconfigFile <filename>") {}


  void visit(const char* value,orbOptions::Source) throw (orbOptions::BadParam) {
    // Do nothing -- already handled before normal arguments are processed
  }

  void dump(orbOptions::sequenceString& result) {
    orbOptions::addKVString(key(), config_fname ? config_fname : "[none]",
			    result);
  }
};

static configFileHandler configFileHandler_;


/////////////////////////////////////////////////////////////////////////////
//            Module initialiser                                           //
/////////////////////////////////////////////////////////////////////////////

class omni_corbaOrb_initialiser : public omniInitialiser {
public:

  omni_corbaOrb_initialiser() {
    orbOptions::singleton().registerHandler(helpHandler_);
    orbOptions::singleton().registerHandler(idHandler_);
    orbOptions::singleton().registerHandler(dumpConfigurationHandler_);
    orbOptions::singleton().registerHandler(lcdModeHandler_);
    orbOptions::singleton().registerHandler(principalHandler_);
    orbOptions::singleton().registerHandler(poa_iiop_portHandler_);
    orbOptions::singleton().registerHandler(poa_iiop_name_portHandler_);
    orbOptions::singleton().registerHandler(configFileHandler_);
  }


  void attach() {

#if !defined(__CIAO__)
# if defined(HAVE_SIGACTION)

    struct sigaction act;
    sigemptyset(&act.sa_mask);
#  ifdef HAVE_SIG_IGN
    act.sa_handler = SIG_IGN;
#  else
    act.sa_handler = (void (*)())0;
#  endif
    act.sa_flags = 0;
    if (sigaction(SIGPIPE,&act,0) < 0) {
      if( omniORB::trace(1) ) {
	omniORB::logger l;
	l << "WARNING -- ORB_init() cannot install the\n"
	  " SIG_IGN handler for signal SIGPIPE. (errno = " << errno << ")\n";
      }
    }
# elif defined(HAVE_SIGVEC)
    struct sigvec act;
    act.sv_mask = 0;
    act.sv_handler = SIG_IGN;
    act.sv_flags = 0;
    if (sigvec(SIGPIPE,&act,0) < 0) {
      if( omniORB::trace(1) ) {
	omniORB::logger l;
	l << "WARNING -- ORB_init() cannot install the\n"
	  " SIG_IGN handler for signal SIGPIPE. (errno = " << errno << ")\n";
      }
    }
# endif // HAVE_SIGACTION
#endif // __CIAO__

    orbAsyncInvoker = new ORBAsyncInvoker(orbParameters::maxServerThreadPoolSize);
    invoker_shutting_down = 0;
  }

  void detach() {
    if (orbAsyncInvoker) {
      if (invoker_threads) {
	omniORB::logs(20, "Wait for ORB invoker threads to finish.");
	while (invoker_threads)
	  invoker_signal.wait();
	omniORB::logs(20, "All ORB invoker threads finished.");
      }
      delete orbAsyncInvoker;
      orbAsyncInvoker = 0;
      invoker_shutting_down = 0;
    }
#ifdef __WIN32__
    (void) WSACleanup();
#endif
  }
};

static omni_corbaOrb_initialiser initialiser;

omniInitialiser& omni_corbaOrb_initialiser_ = initialiser;

OMNI_NAMESPACE_END(omni)