// Insert <naming_context> with <name> relative to <this> context
// (String version)
int
ACE_Registry::Naming_Context::bind_new_context (const ACE_TString &name,
Naming_Context &naming_context,
u_long persistence,
u_long security_access,
LPSECURITY_ATTRIBUTES security_attributes)
{
u_long reason;
long result = ACE_TEXT_RegCreateKeyEx (this->key_,
name.c_str (),
0,
0,
persistence,
security_access,
security_attributes,
&naming_context.key_,
&reason);
if (result == ERROR_SUCCESS)
// If create succeeds
{
if (reason == REG_CREATED_NEW_KEY)
// If new key: success
{
// Set the correct parent
naming_context.parent (this->key_);
// Set the correct name
naming_context.name (name);
}
else
// reason == REG_OPENED_EXISTING_KEY
// Failed to make new key
{
// reset result to failure
result = -1;
// Close the key first
::RegCloseKey (naming_context.key_);
// Reset key
naming_context.key_ = (HKEY) 0;
}
}
ACE_REGISTRY_CALL_RETURN (result);
}
int
ACE_Registry_Name_Space::list_name_entries (ACE_BINDING_SET &set,
const ACE_NS_WString &pattern)
{
ACE_UNUSED_ARG(pattern);
ACE_Registry::Binding_List list;
int result = this->context_.list (list);
if (result != 0)
return result;
// Iterator through all entries
for (ACE_Registry::Binding_List::iterator i = list.begin ();
i != list.end ();
i++)
{
// Yeeesss! STL rules!
ACE_Registry::Binding &binding = *i;
if (binding.type () == ACE_Registry::OBJECT)
{
// Key
ACE_TString string = binding.name ();
ACE_NS_WString key (string.c_str ());
// Value
ACE_NS_WString value;
char *type = 0;
result = this->resolve (key,
value,
type);
if (result != 0)
ACELIB_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("ACE_Registry::Naming_Context::resolve")),
result);
// Complete binding
ACE_Name_Binding binding (key, value, type);
set.insert (binding);
}
}
return 0;
}
int KSGateway::get_scheduler_alg_thr_count(const std::string &alg_name)
{
int count = 0;
std::string config_path = KSGOSUtil::JoinPath(_configuration._basedir,KSG_CONFIG_FILENAME);
ACE_Configuration_Heap config;
if(config.open() == -1)
{
ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1);
}
ACE_Ini_ImpExp config_importer(config);
if(config_importer.import_config(config_path.c_str()) == -1)
{
ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1);
}
ACE_Configuration_Section_Key section;
if(config.open_section(config.root_section(),ACE_TEXT(KSG_COMMON_SECT)
,0,section) == -1)
{
ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1);
}
ACE_TString v;
if(config.open_section(config.root_section(),ACE_TEXT(KSG_SCHEDULER_SECT)
,0,section) == -1)
ACE_ERROR_RETURN((LM_ERROR,ACE_TEXT("读取前置机配置失败")),-1);
std::string key_name = alg_name;
key_name += "_thr_count";
if(config.get_string_value(section,key_name.c_str(),v) == -1)
{
count = 5;
}
else
{
count = ACE_OS::atoi(v.c_str());
count = (count <= 0) ? 5 : count;
}
return count;
}
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
{
try {
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init( argc, argv );
if (parse_args(argc, argv) != 0) {
return 1;
}
// Read and destringify the Messenger object's IOR.
CORBA::Object_var obj = orb->string_to_object(ior.c_str());
if( CORBA::is_nil( obj.in() ) ) {
std::cerr << "Could not get Messenger IOR." << std::endl;
return 1;
}
// Narrow the IOR to a Messenger object reference.
DevGuide::Messenger_var messenger =
DevGuide::Messenger::_narrow( obj.in() );
if( CORBA::is_nil( messenger.in() ) ) {
std::cerr << "IOR was not a Messenger object reference." << std::endl;
return 1;
}
// Send a message the the Messenger object.
CORBA::String_var msg = CORBA::string_dup( "Hello!" );
messenger->send_message( "TAO User", "TAO Test", msg.inout() );
// Print the Messenger's reply.
std::cout << "Reply: " << msg.in() << std::endl;
orb->destroy();
return 0;
}
catch(const CORBA::Exception& ex) {
std::cerr << "CORBA exception: " << ex << std::endl;
}
return 1;
}
bool Config::GetBoolDefault(const char* name, bool def)
{
ACE_TString val;
if (!GetValueHelper(mConf, name, val))
{
return def;
}
const char* str = val.c_str();
if (strcmp(str, "true") == 0 || strcmp(str, "TRUE") == 0 ||
strcmp(str, "yes") == 0 || strcmp(str, "YES") == 0 ||
strcmp(str, "1") == 0)
{
return true;
}
else
{
return false;
}
}
// Find <naming_context> with <name> in <this> context
// (String version)
int
ACE_Registry::Naming_Context::resolve_context (const ACE_TString &name,
Naming_Context &naming_context,
u_long security_access)
{
long result = ACE_TEXT_RegOpenKeyEx (this->key_,
name.c_str (),
0,
security_access,
&naming_context.key_);
if (result == ERROR_SUCCESS)
{
// set the correct parent
naming_context.parent (this->key_);
// set the correct name
naming_context.name (name);
}
ACE_REGISTRY_CALL_RETURN (result);
}
int
SubDriver::parse_pub_arg(const ACE_TString& arg)
{
size_t pos;
// Find the first ':' character, and make sure it is in a legal spot.
if ((pos = std::find(arg.c_str(), arg.c_str() + arg.length(), ACE_TEXT(':')) - arg.c_str()) == arg.length()) {
ACE_ERROR((LM_ERROR,
"(%P|%t) Bad -p command-line value (%s). Missing ':' char.\n",
arg.c_str()));
return -1;
}
if (pos == 0) {
ACE_ERROR((LM_ERROR,
"(%P|%t) Bad -p command-line value (%s). "
"':' char cannot be first char.\n",
arg.c_str()));
return -1;
}
if (pos == (arg.length() - 1)) {
ACE_ERROR((LM_ERROR,
"(%P|%t) Bad -p command-line value (%s) - "
"':' char cannot be last char.\n",
arg.c_str()));
return -1;
}
// Parse the pub_id from left of ':' char, and remainder to right of ':'.
ACE_TString pub_id_str(arg.c_str(), pos);
this->pub_addr_str_ = arg.c_str() + pos + 1;
this->pub_id_fname_ = pub_id_str.c_str();
this->pub_addr_ = ACE_INET_Addr(this->pub_addr_str_.c_str());
return 0;
}
void
IDREF_Base<T>::bind_next_available (ACE_TString &id)
{
// Note: For this function to compile and work properly,
// T must have the postincrement operator defined.
DANCE_TRACE ("IDREF_Base<T>::bind_next_available");
// ACE_DEBUG ((LM_DEBUG, "**** Binding %s to %i\n",
// id.c_str (),
// this->next_));
int retval = idref_map_.bind (id, this->next_);
int pos_retval = pos_map_.bind (this->next_, id);
++this->next_;
if (retval < 0 || pos_retval < 0)
throw Config_Error (id.c_str (),
ACE_TEXT ("Failed to bind an IDRef. This likely indicates a name clash"));
}
CORBA::Contained_ptr
TAO_Repository_i::lookup_id_i (const char *search_id)
{
if (ACE_OS::strcmp (search_id, "IDL:omg.org/CORBA/Object:1.0") == 0
|| ACE_OS::strcmp (search_id, "IDL:omg.org/CORBA/ValueBase:1.0") == 0)
{
return CORBA::Contained::_nil ();
}
ACE_TString path;
if (this->config_->get_string_value (this->repo_ids_key_,
search_id,
path)
!= 0)
{
return CORBA::Contained::_nil ();
}
ACE_Configuration_Section_Key key;
this->config_->expand_path (this->root_key_,
path,
key);
u_int kind = 0;
this->config_->get_integer_value (key,
"def_kind",
kind);
CORBA::DefinitionKind def_kind =
static_cast<CORBA::DefinitionKind> (kind);
CORBA::Object_var obj =
TAO_IFR_Service_Utils::create_objref (def_kind,
path.c_str (),
this->repo_);
return CORBA::Contained::_narrow (obj.in ());
}
virtual int process (Message *message)
{
ACE_TRACE ("SaveMetaData::process()");
ACE_TString path (message->addr ().get_path_name ());
path += ACE_TEXT (".xml");
ACE_FILE_Connector connector;
ACE_FILE_IO file;
ACE_FILE_Addr addr (path.c_str ());
if (connector.connect (file, addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("create meta-data file")),
0);
file.truncate (0);
this->write (file, "<Message>\n");
// ...
this->write (file, "</Message>\n");
file.close ();
return 0;
}
CORBA::DefinitionKind
TAO_IFR_Service_Utils::path_to_def_kind (ACE_TString &path,
TAO_Repository_i *repo)
{
int status =
repo->config ()->expand_path (repo->root_key (),
path,
TAO_IFR_Service_Utils::tmp_key_,
0);
if (status != 0)
{
ORBSVCS_DEBUG ((LM_DEBUG,
"path_to_def_kind - bad path: '%s'\n",
path.c_str ()));
return CORBA::dk_none;
}
u_int kind = 0;
repo->config ()->get_integer_value (TAO_IFR_Service_Utils::tmp_key_,
"def_kind",
kind);
return static_cast<CORBA::DefinitionKind> (kind);
}
void
TAO_OperationDef_i::make_description (
CORBA::OperationDescription &od)
{
od.name = this->name_i ();
od.id = this->id_i ();
ACE_TString container_id;
this->repo_->config ()->get_string_value (this->section_key_,
"container_id",
container_id);
od.defined_in = container_id.c_str ();
od.version = this->version_i ();
od.result = this->result_i ();
od.mode = this->mode_i ();
CORBA::ContextIdSeq_var cid_seq =
this->contexts_i ();
od.contexts = cid_seq.in ();
CORBA::ParDescriptionSeq_var pd_seq =
this->params_i ();
od.parameters = pd_seq.in ();
ACE_Configuration_Section_Key excepts_key;
int status =
this->repo_->config ()->open_section (this->section_key_,
"excepts",
0,
excepts_key);
// This section may not have been created.
if (status == 0)
{
int index = 0;
int status = 0;
ACE_TString field_name, type_path;
ACE_Configuration::VALUETYPE type;
ACE_Unbounded_Queue<ACE_TString> path_queue;
while (this->repo_->config ()->enumerate_values (excepts_key,
index++,
field_name,
type)
== 0)
{
status =
this->repo_->config ()->get_string_value (excepts_key,
field_name.c_str (),
type_path);
if (status == 0)
{
path_queue.enqueue_tail (type_path);
}
}
CORBA::ULong size = static_cast<CORBA::ULong> (path_queue.size ());
od.exceptions.length (size);
for (CORBA::ULong i = 0; i < size; ++i)
{
ACE_TString type_path;
path_queue.dequeue_head (type_path);
ACE_Configuration_Section_Key type_key;
this->repo_->config ()->expand_path (this->repo_->root_key (),
type_path,
type_key,
0);
ACE_TString name;
this->repo_->config ()->get_string_value (type_key,
"name",
name);
od.exceptions[i].name = name.c_str ();
ACE_TString id;
this->repo_->config ()->get_string_value (type_key,
"id",
id);
od.exceptions[i].id = id.c_str ();
ACE_TString container_id;
this->repo_->config ()->get_string_value (type_key,
"container_id",
container_id);
od.exceptions[i].defined_in = container_id.c_str ();
ACE_TString version;
this->repo_->config ()->get_string_value (type_key,
"version",
version);
od.exceptions[i].version = version.c_str ();
TAO_ExceptionDef_i impl (this->repo_);
impl.section_key (type_key);
od.exceptions[i].type = impl.type_i ();
}
}
else
{
od.exceptions.length (0);
}
}
void init ()
{
participant
= dpf->create_participant(domain_id,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_participant failed.\n")));
throw TestException ();
}
::Xyz::FooTypeSupportImpl* fts_servant
= new ::Xyz::FooTypeSupportImpl();
if (::DDS::RETCODE_OK != fts_servant->register_type(participant.in (), type_name))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) register_type failed.\n")));
throw TestException ();
}
::DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
topic[0]
= participant->create_topic (topic_name[0],
type_name,
topic_qos,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic[0].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_topic failed.\n")));
throw TestException ();
}
topic[1]
= participant->create_topic (topic_name[1],
type_name,
topic_qos,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic[1].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_topic failed.\n")));
throw TestException ();
}
writer_impl
= TheTransportFactory->create_transport_impl (PUB_TRAFFIC_TCP,
ACE_TEXT("SimpleTcp"),
OpenDDS::DCPS::DONT_AUTO_CONFIG);
OpenDDS::DCPS::TransportConfiguration_rch writer_config
= TheTransportFactory->create_configuration (PUB_TRAFFIC_TCP, ACE_TEXT("SimpleTcp"));
OpenDDS::DCPS::SimpleTcpConfiguration* writer_tcp_config
= static_cast <OpenDDS::DCPS::SimpleTcpConfiguration*> (writer_config.in ());
if (writer_address_given)
{
ACE_INET_Addr writer_address (writer_address_str.c_str ());
writer_tcp_config->local_address_ = writer_address;
writer_tcp_config->local_address_str_ = writer_address_str.c_str ();
}
// else use default address - OS assigned.
if (writer_impl->configure(writer_config.in()) != 0)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) init_writer_tranport: pub TCP")
ACE_TEXT(" Failed to configure the transport.\n")));
throw TestException ();
}
// Create the default publisher
publisher = participant->create_publisher(PUBLISHER_QOS_DEFAULT,
::DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (publisher.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_publisher failed.\n")));
throw TestException ();
}
// Attach the publisher to the transport.
OpenDDS::DCPS::PublisherImpl* pub_impl
= dynamic_cast<OpenDDS::DCPS::PublisherImpl*>
(publisher.in ());
if (0 == pub_impl)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to obtain publisher servant \n")));
throw TestException ();
}
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to tcp \n")));
OpenDDS::DCPS::AttachStatus attach_status
= pub_impl->attach_transport(writer_impl.in());
if (attach_status != OpenDDS::DCPS::ATTACH_OK)
{
// We failed to attach to the transport for some reason.
ACE_TString status_str;
switch (attach_status)
{
case OpenDDS::DCPS::ATTACH_BAD_TRANSPORT:
status_str = ACE_TEXT("ATTACH_BAD_TRANSPORT");
break;
case OpenDDS::DCPS::ATTACH_ERROR:
status_str = ACE_TEXT("ATTACH_ERROR");
break;
case OpenDDS::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = ACE_TEXT("ATTACH_INCOMPATIBLE_QOS");
break;
default:
status_str = ACE_TEXT("Unknown Status");
break;
}
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to attach to the transport. ")
ACE_TEXT("AttachStatus == %s\n"),
status_str.c_str()));
throw TestException ();
}
// Create the datawriters
::DDS::DataWriterQos dw_qos;
publisher->get_default_datawriter_qos (dw_qos);
// Make it KEEP_ALL history so we can verify the received
// data without dropping.
dw_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
dw_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
dw_qos.resource_limits.max_samples_per_instance = ::DDS::LENGTH_UNLIMITED;
dw_qos.reliability.max_blocking_time.sec = 0;
dw_qos.reliability.max_blocking_time.nanosec = 0;
for (int i = 0; i < 2; ++i)
{
datawriter[i] = publisher->create_datawriter(topic[i].in (),
dw_qos,
::DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (datawriter[i].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datawriter failed.\n")));
throw TestException ();
}
writers[i] = new Writer (datawriter[i].in (), i);
}
}
CORBA::ParDescriptionSeq *
TAO_OperationDef_i::params_i (void)
{
CORBA::ULong i = 0;
ACE_Configuration_Section_Key params_key;
int status =
this->repo_->config ()->open_section (this->section_key_,
"params",
0,
params_key);
ACE_Unbounded_Queue<ACE_Configuration_Section_Key> key_queue;
// This section may not have been created.
if (status == 0)
{
u_int count = 0;
this->repo_->config ()->get_integer_value (params_key,
"count",
count);
for (i = 0; i < count; ++i)
{
ACE_Configuration_Section_Key param_key;
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
status =
this->repo_->config ()->open_section (params_key,
stringified,
0,
param_key);
if (status == 0)
{
key_queue.enqueue_tail (param_key);
}
}
}
CORBA::ULong size = static_cast<CORBA::ULong> (key_queue.size ());
CORBA::ParDescriptionSeq *pd_seq = 0;
ACE_NEW_THROW_EX (pd_seq,
CORBA::ParDescriptionSeq (size),
CORBA::NO_MEMORY ());
pd_seq->length (size);
if (size == 0)
{
return pd_seq;
}
CORBA::ParDescriptionSeq_var retval = pd_seq;
for (i = 0; i < size; ++i)
{
ACE_Configuration_Section_Key key;
key_queue.dequeue_head (key);
ACE_TString name;
this->repo_->config ()->get_string_value (key,
"name",
name);
retval[i].name = name.c_str ();
u_int mode = 0;
this->repo_->config ()->get_integer_value (key,
"mode",
mode);
retval[i].mode = static_cast<CORBA::ParameterMode> (mode);
ACE_TString type_path;
this->repo_->config ()->get_string_value (key,
"type_path",
type_path);
TAO_IDLType_i *impl =
TAO_IFR_Service_Utils::path_to_idltype (type_path,
this->repo_);
// We have an undefined interface
if (impl == 0)
{
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("Encountered undefined parameter type "
"for variable: %s\n"),
name.c_str ()));
throw CORBA::INTF_REPOS ();
}
retval[i].type = impl->type_i ();
CORBA::Object_var obj =
TAO_IFR_Service_Utils::path_to_ir_object (type_path,
this->repo_);
retval[i].type_def = CORBA::IDLType::_narrow (obj.in ());
}
return retval._retn ();
}
CORBA::ExceptionDefSeq *
TAO_OperationDef_i::exceptions_i ( )
{
ACE_Configuration_Section_Key excepts_key;
int status =
this->repo_->config ()->open_section (this->section_key_,
"excepts",
0,
excepts_key);
int index = 0;
ACE_Unbounded_Queue<ACE_TString> path_queue;
// This section may not have been created.
if (status == 0)
{
ACE_TString field_name, type_path;
ACE_Configuration::VALUETYPE type;
while (this->repo_->config ()->enumerate_values (excepts_key,
index++,
field_name,
type)
== 0)
{
this->repo_->config ()->get_string_value (excepts_key,
field_name.c_str (),
type_path);
path_queue.enqueue_tail (type_path);
}
}
CORBA::ULong size = static_cast<CORBA::ULong> (path_queue.size ());
CORBA::ExceptionDefSeq *ed_seq = 0;
ACE_NEW_THROW_EX (ed_seq,
CORBA::ExceptionDefSeq (size),
CORBA::NO_MEMORY ());
ed_seq->length (size);
if (index == 0)
{
return ed_seq;
}
CORBA::ExceptionDefSeq_var retval = ed_seq;
for (CORBA::ULong i = 0; i < size; ++i)
{
ACE_TString path;
path_queue.dequeue_head (path);
CORBA::Object_var obj =
TAO_IFR_Service_Utils::create_objref (CORBA::dk_Exception,
path.c_str (),
this->repo_);
retval[i] = CORBA::ExceptionDef::_narrow (obj.in ());
}
return retval._retn ();
}
int DDS_TEST::test(ACE_TString host, u_short port)
{
if (host.empty() || port == 0) {
std::cerr << "ERROR: -h <host> and -p <port> options are required\n";
return 1;
}
// 0. initialization
ACE_INET_Addr remote_addr(port, host.c_str());
TransportInst_rch inst = TheTransportRegistry->create_inst("my_rtps",
"rtps_udp");
RtpsUdpInst* rtps_inst = dynamic_cast<RtpsUdpInst*>(inst.in());
if (!rtps_inst) {
std::cerr << "ERROR: Failed to cast to RtpsUdpInst\n";
return 1;
}
rtps_inst->datalink_release_delay_ = 0;
rtps_inst->heartbeat_period_ = ACE_Time_Value(0, 100*1000 /*microseconds*/);
TransportConfig_rch cfg = TheTransportRegistry->create_config("cfg");
cfg->instances_.push_back(inst);
TheTransportRegistry->global_config(cfg);
RepoIdBuilder local;
local.federationId(0x01234567); // guidPrefix1
local.participantId(0x89abcdef); // guidPrefix2
local.entityKey(0x012345);
local.entityKind(ENTITYKIND_USER_WRITER_WITH_KEY);
OpenDDS::RTPS::GUID_t local_guid(local);
const OpenDDS::RTPS::GuidPrefix_t& local_prefix = local_guid.guidPrefix;
RepoIdBuilder remote; // these values must match what's in subscriber.cpp
remote.federationId(0x01234567); // guidPrefix1
remote.participantId(0xefcdab89); // guidPrefix2
remote.entityKey(0x452310);
remote.entityKind(ENTITYKIND_USER_READER_WITH_KEY);
LocatorSeq locators;
locators.length(1);
locators[0].kind = (remote_addr.get_type() == AF_INET6)
? LOCATOR_KIND_UDPv6 : LOCATOR_KIND_UDPv4;
locators[0].port = port;
address_to_bytes(locators[0].address, remote_addr);
size_t size_locator = 0, padding_locator = 0;
gen_find_size(locators, size_locator, padding_locator);
ACE_Message_Block mb_locator(size_locator + padding_locator + 1);
Serializer ser_loc(&mb_locator, ACE_CDR_BYTE_ORDER, Serializer::ALIGN_CDR);
ser_loc << locators;
ser_loc << ACE_OutputCDR::from_boolean(false); // requires inline QoS
SimpleDataWriter sdw(local_guid);
sdw.enable_transport(true /*reliable*/, false /*durable*/);
AssociationData subscription;
subscription.remote_id_ = remote;
subscription.remote_reliable_ = false;
subscription.remote_data_.length(1);
subscription.remote_data_[0].transport_type = "rtps_udp";
subscription.remote_data_[0].data.replace(
static_cast<CORBA::ULong>(mb_locator.length()), &mb_locator);
if (!sdw.init(subscription)) {
std::cerr << "publisher TransportClient::associate() failed\n";
return 1;
}
// 1. send by directly writing an RTPS Message to the socket
const Header hdr = { {'R', 'T', 'P', 'S'}, PROTOCOLVERSION, VENDORID_OPENDDS,
{local_prefix[0], local_prefix[1], local_prefix[2], local_prefix[3],
local_prefix[4], local_prefix[5], local_prefix[6], local_prefix[7],
local_prefix[8], local_prefix[9], local_prefix[10], local_prefix[11]} };
const ACE_Time_Value now = ACE_OS::gettimeofday();
log_time(now);
const double conv = 4294.967296; // NTP fractional (2^-32) sec per microsec
const InfoTimestampSubmessage it = { {INFO_TS, 1, 8},
{static_cast<ACE_CDR::Long>(now.sec()),
static_cast<ACE_CDR::ULong>(now.usec() * conv)} };
DataSubmessage ds = { {DATA, 7, 20 + 24 + 12 + sizeof(text)}, 0, 16,
ENTITYID_UNKNOWN, local_guid.entityId, {0, 1}, ParameterList() };
TestMsg data;
data.key = 0x09230923;
data.value = text;
ds.inlineQos.length(1);
OpenDDS::RTPS::KeyHash_t hash;
marshal_key_hash(data, hash);
ds.inlineQos[0].key_hash(hash);
const ACE_CDR::ULong encap = 0x00000100; // {CDR_LE, options} in BE format
size_t size = 0, padding = 0;
gen_find_size(hdr, size, padding);
gen_find_size(it, size, padding);
gen_find_size(ds, size, padding);
find_size_ulong(size, padding);
gen_find_size(data, size, padding);
ACE_Message_Block msg(size + padding);
Serializer ser(&msg, host_is_bigendian, Serializer::ALIGN_CDR);
bool ok = (ser << hdr) && (ser << it) && (ser << ds)
&& (ser << encap) && (ser << data);
if (!ok) {
std::cerr << "ERROR: failed to serialize RTPS message\n";
return 1;
}
ACE_INET_Addr local_addr;
ACE_SOCK_Dgram sock(local_addr);
ssize_t res = sock.send(msg.rd_ptr(), msg.length(), remote_addr);
if (res < 0) {
std::cerr << "ERROR: error in send()\n";
return 1;
} else {
std::ostringstream oss;
oss << "Sent " << res << " bytes.\n";
ACE_DEBUG((LM_INFO, oss.str().c_str()));
}
// 2a. send control messages through the OpenDDS transport
// Send an instance registration
{
TestMsg control_sample;
control_sample.key = 0x04030201;
DataSampleHeader dsh;
dsh.message_id_ = INSTANCE_REGISTRATION;
dsh.sequence_ = SequenceNumber::SEQUENCENUMBER_UNKNOWN();
dsh.publication_id_ = local_guid;
dsh.key_fields_only_ = true;
// Calculate the data buffer length
size = 0;
padding = 0;
OpenDDS::DCPS::KeyOnly<const TestMsg> ko_instance_data(control_sample);
find_size_ulong(size, padding); // encap
gen_find_size(ko_instance_data, size, padding);
dsh.message_length_ = static_cast<ACE_UINT32>(size + padding);
ACE_Message_Block* ir_mb = new ACE_Message_Block(DataSampleHeader::max_marshaled_size(),
ACE_Message_Block::MB_DATA,
new ACE_Message_Block(dsh.message_length_));
*ir_mb << dsh;
OpenDDS::DCPS::Serializer serializer(ir_mb->cont(),
host_is_bigendian,
Serializer::ALIGN_CDR);
ok = (serializer << encap) && (serializer << ko_instance_data);
if (!ok) {
std::cerr << "ERROR: failed to serialize data for instance registration\n";
return 1;
}
::DDS_TEST::force_inline_qos(false); // No inline QoS
sdw.send_control(dsh, ir_mb);
// Send a dispose instance
{
dsh.message_id_ = DISPOSE_INSTANCE;
ACE_Message_Block* di_mb = new ACE_Message_Block(DataSampleHeader::max_marshaled_size(),
ACE_Message_Block::MB_DATA,
new ACE_Message_Block(dsh.message_length_));
*di_mb << dsh;
OpenDDS::DCPS::Serializer serializer(di_mb->cont(),
host_is_bigendian,
Serializer::ALIGN_CDR);
ok = (serializer << encap) && (serializer << ko_instance_data);
if (!ok) {
std::cerr << "ERROR: failed to serialize data for dispose instance\n";
return 1;
}
::DDS_TEST::force_inline_qos(true); // Inline QoS
sdw.inline_qos_mode_ = SimpleDataWriter::PARTIAL_MOD_QOS;
sdw.send_control(dsh, di_mb);
}
// Send an unregister instance
{
dsh.message_id_ = UNREGISTER_INSTANCE;
ACE_Message_Block* ui_mb = new ACE_Message_Block(DataSampleHeader::max_marshaled_size(),
ACE_Message_Block::MB_DATA,
new ACE_Message_Block(dsh.message_length_));
*ui_mb << dsh;
OpenDDS::DCPS::Serializer serializer(ui_mb->cont(),
host_is_bigendian,
Serializer::ALIGN_CDR);
ok = (serializer << encap) && (serializer << ko_instance_data);
if (!ok) {
std::cerr << "ERROR: failed to serialize data for unregister instance\n";
return 1;
}
::DDS_TEST::force_inline_qos(true); // Inline QoS
sdw.inline_qos_mode_ = SimpleDataWriter::FULL_MOD_QOS;
sdw.send_control(dsh, ui_mb);
}
// Send a dispose & unregister instance
{
dsh.message_id_ = DISPOSE_UNREGISTER_INSTANCE;
ACE_Message_Block* ui_mb = new ACE_Message_Block(DataSampleHeader::max_marshaled_size(),
ACE_Message_Block::MB_DATA,
new ACE_Message_Block(dsh.message_length_));
*ui_mb << dsh;
OpenDDS::DCPS::Serializer serializer(ui_mb->cont(),
host_is_bigendian,
Serializer::ALIGN_CDR);
ok = (serializer << encap) && (serializer << ko_instance_data);
if (!ok) {
std::cerr << "ERROR: failed to serialize data for dispose unregister instance\n";
return 1;
}
::DDS_TEST::force_inline_qos(true); // Inline QoS
sdw.inline_qos_mode_ = SimpleDataWriter::FULL_MOD_QOS;
sdw.send_control(dsh, ui_mb);
}
}
// 2b. send sample data through the OpenDDS transport
TransportSendElementAllocator alloc(2, sizeof(TransportSendElementAllocator));
DataSampleElement elements[] = {
DataSampleElement(local_guid, &sdw, 0, &alloc, 0), // Data Sample
DataSampleElement(local_guid, &sdw, 0, &alloc, 0), // Data Sample (key=99 means end)
};
SendStateDataSampleList list;
list.head_ = elements;
list.size_ = sizeof(elements) / sizeof(elements[0]);
list.tail_ = &elements[list.size() - 1];
for (int i = 0; i < list.size() - 1; ++i) {
DDS_TEST::set_next_send_sample(elements[i], &elements[i + 1]);
}
// Send a regular data sample
int index = 0;
DataSampleHeader& dsh = elements[index].header_;
dsh.message_id_ = SAMPLE_DATA;
dsh.publication_id_ = local_guid;
dsh.sequence_ = 3; // test GAP generation
const ACE_Time_Value tv = ACE_OS::gettimeofday();
log_time(tv);
DDS::Time_t st = time_value_to_time(tv);
dsh.source_timestamp_sec_ = st.sec;
dsh.source_timestamp_nanosec_ = st.nanosec;
// Calculate the data buffer length
size = 0;
padding = 0;
find_size_ulong(size, padding); // encap
gen_find_size(data, size, padding);
dsh.message_length_ = static_cast<ACE_UINT32>(size + padding);
elements[index].sample_ =
new ACE_Message_Block(DataSampleHeader::max_marshaled_size(),
ACE_Message_Block::MB_DATA, new ACE_Message_Block(dsh.message_length_));
*elements[index].sample_ << dsh;
Serializer ser2(elements[index].sample_->cont(), host_is_bigendian,
Serializer::ALIGN_CDR);
ok = (ser2 << encap) && (ser2 << data);
if (!ok) {
std::cerr << "ERROR: failed to serialize data for elements[" << index << "]\n";
return 1;
}
// Send a data sample with a key of 99 to terminate the subscriber
index++;
DataSampleHeader& dsh2 = elements[index].header_;
dsh2.sequence_ = dsh.sequence_+1;
dsh2.message_id_ = SAMPLE_DATA;
dsh.publication_id_ = local_guid;
dsh2.key_fields_only_ = false;
const ACE_Time_Value tv2 = ACE_OS::gettimeofday();
log_time(tv2);
DDS::Time_t st2 = time_value_to_time(tv2);
dsh2.source_timestamp_sec_ = st2.sec;
dsh2.source_timestamp_nanosec_ = st2.nanosec;
data.key = 99;
data.value = "";
// Calculate the data buffer length
size = 0;
padding = 0;
find_size_ulong(size, padding); // encap
gen_find_size(data, size, padding);
dsh2.message_length_ = static_cast<ACE_UINT32>(size + padding);
elements[index].sample_ =
new ACE_Message_Block(DataSampleHeader::max_marshaled_size(),
ACE_Message_Block::MB_DATA, new ACE_Message_Block(dsh2.message_length_));
*elements[index].sample_ << dsh2;
Serializer ser3(elements[index].sample_->cont(), host_is_bigendian,
Serializer::ALIGN_CDR);
ok = (ser3 << encap) && (ser3 << data.key) && (ser3 << data.value);
if (!ok) {
std::cerr << "ERROR: failed to serialize data for elements[" << index << "]\n";
return 1;
}
sdw.callbacks_expected_ = list.size();
::DDS_TEST::force_inline_qos(true); // Inline QoS
sdw.send(list);
while (sdw.callbacks_expected_) {
ACE_OS::sleep(1);
}
// Allow enough time for a HEARTBEAT message to be generated
ACE_OS::sleep(rtps_inst->heartbeat_period_ * 2.0);
// 3. cleanup
sdw.disassociate(subscription.remote_id_);
TheServiceParticipant->shutdown();
ACE_Thread_Manager::instance()->wait();
return 0;
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
int retval = 0;
MCT_Config config;
retval = config.open (argc, argv);
if (retval != 0)
return 1;
const ACE_TCHAR *temp = ACE_TEXT ("Multicast_Test");
ACE_TString test = temp;
u_long role = config.role ();
if (ACE_BIT_DISABLED (role, MCT_Config::PRODUCER)
|| ACE_BIT_DISABLED (role, MCT_Config::CONSUMER))
{
if (ACE_BIT_ENABLED (role, MCT_Config::PRODUCER))
test += ACE_TEXT ("-PRODUCER");
else
test += ACE_TEXT ("-CONSUMER");
}
// Start test only if options are valid.
ACE_START_TEST (test.c_str ());
// Register a signal handler to close down application gracefully.
ACE_Sig_Action sa ((ACE_SignalHandler) handler, SIGINT);
// Dump the configuration info to the log if caller passed debug option.
if (config.debug ())
config.dump ();
ACE_Reactor *reactor = ACE_Reactor::instance ();
MCT_Task *task = new MCT_Task (config, reactor);
if (ACE_BIT_ENABLED (role, MCT_Config::CONSUMER))
{
ACE_DEBUG ((LM_INFO, ACE_TEXT ("Starting consumer...\n")));
// Open makes it an active object.
retval += task->open ();
}
// now produce the datagrams...
if (ACE_BIT_ENABLED (role, MCT_Config::PRODUCER))
retval += producer (config);
if (ACE_BIT_ENABLED (role, MCT_Config::CONSUMER))
{
// and wait for everything to finish
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("start waiting for consumer to finish...\n")));
// Wait for the threads to exit.
// But, wait for a limited time since we could hang if the last udp
// message isn't received.
ACE_Time_Value max_wait ( config.wait ()/* seconds */);
ACE_Time_Value wait_time (ACE_OS::gettimeofday () + max_wait);
ACE_Time_Value *ptime = ACE_BIT_ENABLED (role, MCT_Config::PRODUCER)
? &wait_time : 0;
if (ACE_Thread_Manager::instance ()->wait (ptime) == -1)
{
// We will no longer wait for this thread, so we must
// force it to exit otherwise the thread will be referencing
// deleted memory.
finished = 1;
reactor->end_reactor_event_loop ();
if (errno == ETIME)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("maximum wait time of %d msec exceeded\n"),
max_wait.msec ()));
else
ACE_OS::perror (ACE_TEXT ("wait"));
++error;
// This should exit now that we ended the reactor loop.
task->wait ();
}
}
delete task;
ACE_END_TEST;
return (retval == 0 && error == 0) ? 0 : 1;
}
void
TAO_InterfaceDef_i::interface_contents (
ACE_Unbounded_Queue<CORBA::DefinitionKind> &kind_queue,
ACE_Unbounded_Queue<ACE_TString> &path_queue,
CORBA::DefinitionKind limit_type,
CORBA::Boolean exclude_inherited
)
{
ACE_TString id;
this->repo_->config ()->get_string_value (this->section_key_,
"id",
id);
ACE_TString path;
this->repo_->config ()->get_string_value (this->repo_->repo_ids_key (),
id.c_str (),
path);
ACE_TString section_name;
int index = 0;
int status = 0;
// Attributes
if (limit_type == CORBA::dk_Attribute
|| limit_type == CORBA::dk_all)
{
ACE_Configuration_Section_Key attrs_key;
status =
this->repo_->config ()->open_section (this->section_key_,
"attrs",
0,
attrs_key);
// Only if we have any.
if (status == 0)
{
while (this->repo_->config ()->enumerate_sections (attrs_key,
index++,
section_name)
== 0)
{
kind_queue.enqueue_tail (CORBA::dk_Attribute);
path_queue.enqueue_tail (
path + "\\attrs\\" + section_name.c_str ()
);
}
}
}
// Operations
if (limit_type == CORBA::dk_Operation
|| limit_type == CORBA::dk_all)
{
index = 0;
ACE_Configuration_Section_Key ops_key;
status =
this->repo_->config ()->open_section (this->section_key_,
"ops",
0,
ops_key);
// Only if we have any.
if (status == 0)
{
while (this->repo_->config ()->enumerate_sections (ops_key,
index++,
section_name)
== 0)
{
kind_queue.enqueue_tail (CORBA::dk_Operation);
path_queue.enqueue_tail (
path + "\\ops\\" + section_name.c_str ()
);
}
}
}
if (exclude_inherited == 0)
{
// Must recurse through the base interfaces.
ACE_Configuration_Section_Key inherited_key;
status =
this->repo_->config ()->open_section (this->section_key_,
"inherited",
0,
inherited_key);
if (status == 0)
{
ACE_TString base_path;
ACE_Configuration_Section_Key base_key;
ACE_Configuration::VALUETYPE type;
index = 0;
while (this->repo_->config ()->enumerate_values (inherited_key,
index++,
section_name,
type)
== 0)
{
this->repo_->config ()->get_string_value (inherited_key,
section_name.c_str (),
base_path);
this->repo_->config ()->expand_path (this->repo_->root_key (),
base_path,
base_key,
0);
TAO_InterfaceDef_i base_iface (this->repo_);
base_iface.section_key (base_key);
base_iface.interface_contents (kind_queue,
path_queue,
limit_type,
exclude_inherited);
}
}
}
}
CORBA::Contained::Description *
TAO_ComponentDef_i::describe_i (void)
{
CORBA::ComponentIR::ComponentDescription cd;
TAO_IFR_Desc_Utils<CORBA::ComponentIR::ComponentDescription,
TAO_ComponentDef_i>::fill_desc_begin (
cd,
this->repo_,
this->section_key_
);
ACE_TString holder;
int status =
this->repo_->config ()->get_string_value (this->section_key_,
"base_component",
holder);
if (status == 0)
{
ACE_Configuration_Section_Key base_key;
this->repo_->config ()->expand_path (this->repo_->root_key (),
holder,
base_key,
0);
this->repo_->config ()->get_string_value (base_key,
"id",
holder);
}
// If status wasn't 0, holder will contain the empty string.
cd.base_component = holder.fast_rep ();
CORBA::ULong count = 0;
ACE_Configuration_Section_Key supports_key;
status = this->repo_->config ()->open_section (this->section_key_,
"supported",
0,
supports_key);
if (status == 0)
{
this->repo_->config ()->get_integer_value (supports_key,
"count",
count);
}
cd.supported_interfaces.length (count);
char *stringified = 0;
CORBA::ULong i = 0;
for (i = 0; i < count; ++i)
{
stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->get_string_value (supports_key,
stringified,
holder);
cd.supported_interfaces[i] = holder.c_str ();
}
TAO_Port_Desc_Seq_Utils<
CORBA::ComponentIR::ProvidesDescriptionSeq
>::port_descriptions (cd.provided_interfaces,
this->repo_->config (),
this->section_key_,
"provides");
TAO_Port_Desc_Seq_Utils<
CORBA::ComponentIR::UsesDescriptionSeq
>::port_descriptions (cd.used_interfaces,
this->repo_->config (),
this->section_key_,
"uses");
TAO_Port_Desc_Seq_Utils<
CORBA::ComponentIR::EventPortDescriptionSeq
>::port_descriptions (cd.emits_events,
this->repo_->config (),
this->section_key_,
"emits");
TAO_Port_Desc_Seq_Utils<
CORBA::ComponentIR::EventPortDescriptionSeq
>::port_descriptions (cd.publishes_events,
this->repo_->config (),
this->section_key_,
"publishes");
TAO_Port_Desc_Seq_Utils<
CORBA::ComponentIR::EventPortDescriptionSeq
>::port_descriptions (cd.consumes_events,
this->repo_->config (),
this->section_key_,
"consumes");
count = 0;
ACE_Configuration_Section_Key attrs_key;
status =
this->repo_->config ()->open_section (this->section_key_,
"attrs",
0,
attrs_key);
if (status == 0)
{
this->repo_->config ()->get_integer_value (attrs_key,
"count",
count);
}
cd.attributes.length (count);
ACE_Configuration_Section_Key attr_key;
for (i = 0; i < count; ++i)
{
stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->open_section (attrs_key,
stringified,
0,
attr_key);
TAO_ExtAttributeDef_i impl (this->repo_);
impl.section_key (attr_key);
impl.fill_description (cd.attributes[i]);
}
cd.type = this->type_i ();
CORBA::Contained::Description *cont_desc_ptr = 0;
ACE_NEW_THROW_EX (cont_desc_ptr,
CORBA::Contained::Description,
CORBA::NO_MEMORY ());
CORBA::Contained::Description_var retval = cont_desc_ptr;
cont_desc_ptr->kind = CORBA::dk_Component;
cont_desc_ptr->value <<= cd;
return retval._retn ();
}
int ACE_TMAIN (int argc, ACE_TCHAR **argv)
{
DANCE_DISABLE_TRACE ();
auto_ptr<DAnCE::Logger_Service> logger;
int retval (0);
try
{
DAnCE::Logger_Service
* dlf = ACE_Dynamic_Service<DAnCE::Logger_Service>::instance ("DAnCE_Logger");
if (dlf)
{
dlf->init (argc, argv);
}
DANCE_TRACE_LOG (DANCE_LOG_TRACE,
(LM_TRACE, DLINFO
ACE_TEXT ("Module_main.h - initializing ORB\n")));
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
Options options;
int const error = options.parse_args (argc, argv);
if (error == -1)
{
DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ")
ACE_TEXT ("Failed to parse command line arguments.\n")));
}
else if (error == 1)
{ //help was issued -> quit
return 0;
}
if (options.rm_ior_ == 0)
{
DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ")
ACE_TEXT ("No RepositoryManager IOR provided\n")));
return -1;
}
// Resolve the RepositoryManager reference
CORBA::Object_var obj = orb->string_to_object (options.rm_ior_);
Deployment::RepositoryManager_var rm =
Deployment::RepositoryManager::_narrow (obj);
if (CORBA::is_nil (obj))
{
DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ")
ACE_TEXT ("Provided IOR was invalid or could not be narrowed: %s\n"),
options.rm_ior_));
return -1;
}
DAnCE::RepositoryManager::Admin admin (rm.in ());
ACE_Unbounded_Set_Iterator<Options::Installation> inst_it =
options.install_.begin ();
Options::Installation *inst (0);
while (inst_it.next (inst) == 1)
{
if (!admin.install_package (inst->path_.c_str (),
inst->name_.c_str (),
inst->replace_))
retval = -1;
inst_it.advance ();
}
ACE_Unbounded_Set_Iterator<Options::Creation> creat_it (options.create_);
Options::Creation *creat (0);
while (creat_it.next (creat) == 1)
{
if (!admin.create_package (creat->path_.c_str (),
creat->name_.c_str (),
creat->base_location_.c_str (),
creat->replace_))
retval = -1;
creat_it.advance ();
}
ACE_Unbounded_Set_Iterator<ACE_TString> uninst_it (options.uninstall_);
ACE_TString *uninst = 0;
while (uninst_it.next (uninst) == 1)
{
if (!admin.uninstall_package (uninst->c_str ()))
retval = -1;
uninst_it.advance ();
}
if (options.list_)
{
::CORBA::StringSeq * packages = admin.list_packages ();
if (packages == 0)
{
DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ")
ACE_TEXT ("No packages returned from list_packages\n")));
retval = -1;
}
DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO,
(LM_EMERGENCY, ACE_TEXT ("Listing %u packages installed on server:\n")));
for (CORBA::ULong i = 0; i < packages->length (); ++i)
{
DANCE_TRACE_LOG (DANCE_LOG_DETAILED_TRACE, (LM_TRACE, "\t%s\n",
(*packages)[i].in ()));
}
delete packages;
}
if (options.shutdown_)
{
DANCE_DEBUG (DANCE_LOG_MAJOR_EVENT,
(LM_EMERGENCY, ACE_TEXT ("Shutting down the Repository Manager\n")));
if (!admin.shutdown ())
retval = -1;
}
orb->destroy ();
}
catch (const CORBA::Exception &ex)
{
DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ")
ACE_TEXT ("Caught unexpected CORBA Exception: %s\n"),
ex._info ().c_str ()));
return -1;
}
catch (...)
{
DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ")
ACE_TEXT ("Caught unexpected C++ exception.\n")));
return -1;
}
return retval;
}
std::string FileConfig::GetStringDefault(const char* name, const char* def)
{
ACE_TString val;
return GetValueHelper(mConf, name, val) ? val.c_str() : def;
}
void Directory::scan_dir(const ACE_TString& relative, DDS_Dirent& dir,
unsigned int overflow_index)
{
ACE_TString path = physical_dirname_ + relative;
add_slash(path);
while (DDS_DIRENT* ent = dir.read()) {
if (ent->d_name[0] == ACE_TEXT('.') && (!ent->d_name[1] ||
(ent->d_name[1] == ACE_TEXT('.') && !ent->d_name[2]))) {
continue; // skip '.' and '..'
}
ACE_TString file = path + ent->d_name;
if (is_dir(file.c_str())) {
ACE_TString phys(relative);
add_slash(phys);
phys += ent->d_name;
if (ACE_OS::strncmp(ent->d_name, ACE_TEXT("_overflow."), 10) == 0) {
unsigned int n = ACE_OS::atoi(ent->d_name + 10);
DDS_Dirent overflow(file.c_str());
scan_dir(ent->d_name, overflow, n);
} else if (ACE_OS::strlen(ent->d_name) <= FSS_MAX_FILE_NAME_ENCODED) {
dirs_[b32h_decode(ent->d_name)] = phys;
++overflow_[overflow_index];
} else {
CwdGuard cg(file);
std::ifstream fn("_fullname");
std::string fullname;
if (!std::getline(fn, fullname)) {
throw std::runtime_error("Can't read .../_fullname");
}
ACE_TString full_t(ACE_TEXT_CHAR_TO_TCHAR(fullname.c_str()));
dirs_[full_t] = phys;
++overflow_[overflow_index];
String_Index_t idx = phys.rfind(ACE_TEXT('.'));
if (idx == ACE_TString::npos) {
throw std::runtime_error("Badly formatted long dir name");
}
ACE_TString prefix(phys.c_str(), idx);
unsigned int serial = ACE_OS::atoi(&phys[idx + 1]);
unsigned int& counter = long_names_[prefix];
if (serial >= counter) counter = serial + 1;
}
} else { // regular file
if (ent->d_name[0] != ACE_TEXT('_')) {
files_[b32h_decode(ent->d_name)] = ent->d_name;
++overflow_[overflow_index];
}
}
}
}
int GetIntDefault(const char* name, int def)
{
ACE_TString val;
return GetValueHelper(name, val) ? atoi(val.c_str()) : def;
};
std::string GetStringDefault(const char* name, const std::string &def)
{
ACE_TString val;
return GetValueHelper(name, val) ? val.c_str() : def;
};
int32 FileConfig::GetIntDefault(const char* name, int32 def)
{
ACE_TString val;
return GetValueHelper(mConf, name, val) ? atoi(val.c_str()) : def;
}
void
Locator_XMLHandler::startElement (const ACEXML_Char*,
const ACEXML_Char*,
const ACEXML_Char* qName,
ACEXML_Attributes* attrs)
{
if (ACE_OS::strcasecmp (qName, SERVER_INFO_TAG) == 0)
{
ACE_NEW (this->si_, Server_Info);
this->env_vars_.clear ();
// if attrs exists and if the previously required 9 fields
const size_t previous_size = 9;
if (attrs != 0 && attrs->getLength () >= previous_size)
{
size_t index = 0;
this->si_->server_id = ACE_TEXT_ALWAYS_CHAR (attrs->getValue (index++));
this->si_->poa_name = ACE_TEXT_ALWAYS_CHAR (attrs->getValue (index++));
this->si_->activator = ACE_TEXT_ALWAYS_CHAR (attrs->getValue (index++));
this->si_->cmdline = ACE_TEXT_ALWAYS_CHAR (attrs->getValue (index++));
this->si_->dir = ACE_TEXT_ALWAYS_CHAR (attrs->getValue (index++));
this->si_->activation_mode_ =
ImR_Utils::stringToActivationMode (ACE_TEXT_ALWAYS_CHAR (attrs->getValue (index++)));
this->si_->start_limit_ = ACE_OS::atoi (attrs->getValue (index++));
this->si_->partial_ior = ACE_TEXT_ALWAYS_CHAR (attrs->getValue (index++));
this->si_->ior = ACE_TEXT_ALWAYS_CHAR (attrs->getValue (index++));
if (attrs->getLength () >= index)
{
this->server_started_ =
(ACE_OS::atoi (attrs->getValue (index++)) != 0);
}
if (attrs->getLength () >= index)
{
this->si_->is_jacorb =
(ACE_OS::atoi (attrs->getValue (index++)) != 0);
}
for ( ; index < attrs->getLength(); ++index)
{
ACE_TString name (attrs->getLocalName (index));
ACE_CString value (ACE_TEXT_ALWAYS_CHAR (attrs->getValue (index)));
if (name == KEYNAME_TAG)
{
this->si_->key_name_ = value;
}
else if (name == ALTKEY_TAG)
{
if (value.length() > 0 &&
this->repo_.servers ().find (value, this->si_->alt_info_) != 0)
{
Server_Info *base_si = 0;
ACE_NEW (base_si, Server_Info);
base_si->key_name_ = value;
this->si_->alt_info_.reset (base_si);
this->repo_.servers ().bind (value, this->si_->alt_info_);
}
}
else if (name == PID_TAG)
{
this->si_->pid =
ACE_OS::atoi (attrs->getValue (index++));
}
else
{
const ACE_CString name_cstr (ACE_TEXT_ALWAYS_CHAR (name.c_str ()));
this->extra_params_.push_back (std::make_pair (name_cstr, value));
}
}
}
}
else if (ACE_OS::strcasecmp (qName, ACTIVATOR_INFO_TAG) == 0)
{
if (attrs != 0 && attrs->getLength () >= 3)
{
size_t index = 0;
const ACE_CString aname =
ACE_TEXT_ALWAYS_CHAR(attrs->getValue (index++));
const ACE_TString token_str = attrs->getValue (index++);
long token = ACE_OS::atoi (token_str.c_str ());
const ACE_CString ior =
ACE_TEXT_ALWAYS_CHAR(attrs->getValue (index++));
NameValues extra_params;
for ( ; index < attrs->getLength(); ++index)
{
ACE_CString name (ACE_TEXT_ALWAYS_CHAR (attrs->getLocalName(index)));
ACE_CString value (ACE_TEXT_ALWAYS_CHAR (attrs->getValue(index)));
extra_params.push_back (std::make_pair (name, value));
}
this->repo_.load_activator (aname, token, ior, extra_params);
}
}
else if (ACE_OS::strcasecmp (qName, ENVIRONMENT_TAG) == 0)
{
if (attrs != 0 && attrs->getLength () == 2)
{
EnvVar ev;
ev.name = attrs->getValue ((size_t)0);
ev.value = attrs->getValue ((size_t)1);
this->env_vars_.push_back (ev);
}
}
else if (ACE_OS::strcasecmp (qName, PEER_TAG) == 0)
{
if (attrs != 0)
{
ACE_CString peer (ACE_TEXT_ALWAYS_CHAR (attrs->getValue((size_t)0)));
this->peer_list_.push_back (peer);
}
}
}
float FileConfig::GetFloatDefault(const char* name, float def)
{
ACE_TString val;
return GetValueHelper(mConf, name, val) ? (float)atof(val.c_str()) : def;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
// Create a MessengerServer object.
MessengerServer * server = new MessengerServer (orb.in());
ACE_Auto_Ptr<MessengerServer> safe_ptr (server);
// Parse arguments to determine how we should shutdown.
if (server->parse_args (argc, argv) != 0)
return 1;
//Get reference to the RootPOA.
CORBA::Object_var obj = orb->resolve_initial_references( "RootPOA" );
PortableServer::POA_var poa = PortableServer::POA::_narrow( obj.in() );
// Activate the POAManager.
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
// Create a servant.
Messenger_i messenger_servant (orb.in());
// Register the servant with the RootPOA, obtain its object
// reference, stringify it, and write it to a file.
PortableServer::ObjectId_var oid =
poa->activate_object( &messenger_servant );
CORBA::Object_var messenger_obj = poa->id_to_reference( oid.in() );
CORBA::String_var str = orb->object_to_string( messenger_obj.in() );
std::ofstream iorFile(ACE_TEXT_ALWAYS_CHAR (ior_output_file.c_str ()));
iorFile << str.in() << std::endl;
iorFile.close();
std::cout << "IOR written to file " <<
ACE_TEXT_ALWAYS_CHAR (ior_output_file.c_str ()) << std::endl;
switch (s_method)
{
// shutdown on client invocation
case MessengerServer::s_client_call:
std::cout << "Will shutdown on client invocation." << std::endl;
server->run ();
break;
// shutdown after some iterations through loop
case MessengerServer::s_polling_loop:
server->poll (loop_iterations);
break;
// schedule a timer to shutdown
case MessengerServer::s_timer:
server->schedule_shutdown_timer (timeout);
server->run ();
break;
// shutdown on console input
case MessengerServer::s_console_input:
server->shutdown_on_console_input ();
server->run ();
break;
// use CORBA::ORB::run() with time value
case MessengerServer::s_run_time_value:
server->run (timeout);
break;
}
}
catch(const CORBA::Exception& ex) {
std::cerr << "CORBA exception: " << ex << std::endl;
return 1;
}
return 0;
}
int
ACE_DLL_Handle::open (const ACE_TCHAR *dll_name,
int open_mode,
ACE_SHLIB_HANDLE handle)
{
ACE_TRACE ("ACE_DLL_Handle::open");
ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0));
if (this->dll_name_)
{
// Once dll_name_ has been set, it can't be changed..
if (ACE_OS::strcmp (this->dll_name_, dll_name) != 0)
{
if (ACE::debug ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) DLL_Handle::open: error, ")
ACE_TEXT ("tried to reopen %s with name %s\n"),
this->dll_name_,
dll_name));
return -1;
}
}
else
this->dll_name_ = ACE::strnew (dll_name);
if (!this->open_called_)
this->open_called_ = 1;
// If it hasn't been loaded yet, go ahead and do that now.
if (this->handle_ == ACE_SHLIB_INVALID_HANDLE)
{
if (handle)
this->handle_ = handle;
else
{
/*
** Get the set of names to try loading. We need to do this to
** properly support the ability for a user to specify a simple,
** unadorned name (for example, "ACE") that will work across
** platforms. We apply platform specifics to get a name that will
** work (e.g. libACE, ACEd.dll, ACE.dll, etc.) We rely on the
** underlying dlopen() implementation to "Do The Right Thing" in
** terms of using relative paths, LD_LIBRARY_PATH, system security
** rules, etc. except when ACE_MUST_HELP_DLOPEN_SEARCH_PATH is set.
** If it is set, then ACE::ldfind() scans the configured path
** looking for a match on the name and prefix/suffix applications.
** NOTE: having ACE scan for a file and then pass a fully-qualified
** pathname to dlopen() is a potential security hole; therefore,
** do not use ACE_MUST_HELP_DLOPEN_SEARCH_PATH unless necessary
** and only after considering the risks.
*/
ACE_Array<ACE_TString> dll_names;
dll_names.max_size (10); // Decent guess to avoid realloc later
#if defined (ACE_MUST_HELP_DLOPEN_SEARCH_PATH)
// Find out where the library is
ACE_TCHAR dll_pathname[MAXPATHLEN + 1];
// Transform the pathname into the appropriate dynamic link library
// by searching the ACE_LD_SEARCH_PATH.
ACE::ldfind (dll_name,
dll_pathname,
(sizeof dll_pathname / sizeof (ACE_TCHAR)));
ACE_TString dll_str (dll_pathname);
dll_names.size (1);
dll_names.set (dll_str, 0);
#else
this->get_dll_names (dll_name, dll_names);
#endif
ACE_Array_Iterator<ACE_TString> name_iter (dll_names);
ACE_TString *name = 0;
while (name_iter.next (name))
{
// The ACE_SHLIB_HANDLE object is obtained.
this->handle_ = ACE_OS::dlopen (name->c_str (),
open_mode);
if (ACE::debug ())
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("ACE (%P|%t) DLL_Handle::open ")
ACE_TEXT ("(\"%s\", 0x%x) -> %s: %s\n"),
name->c_str (),
open_mode,
((this->handle_ != ACE_SHLIB_INVALID_HANDLE)
? ACE_TEXT ("succeeded")
: ACE_TEXT ("failed")),
this->error()->c_str()));
}
if (this->handle_ != ACE_SHLIB_INVALID_HANDLE) // Good one?
break;
// If errno is ENOENT we just skip over this one,
// anything else - like an undefined symbol, for
// instance must be flagged here or the next error will
// mask it.
// @TODO: If we've found our DLL _and_ it's
// broken, should we continue at all?
if ((errno != 0) && (errno != ENOENT) && ACE::debug ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE (%P|%t) DLL_Handle::open ")
ACE_TEXT ("(\'%s\') failed, errno=")
ACE_TEXT ("%d: %s\n"),
name->c_str (),
errno,
this->error ()->c_str ()));
#if defined (AIX)
// AIX often puts the shared library file (most often named
// shr.o) inside an archive library. If this is an archive
// library name, then try appending [shr.o] and retry.
if (ACE_TString::npos != name->strstr (ACE_TEXT (".a")))
{
ACE_TCHAR aix_pathname[MAXPATHLEN + 1];
ACE_OS::strncpy (aix_pathname,
name->c_str (),
name->length ());
aix_pathname[name->length ()] = '\0';
ACE_OS::strcat (aix_pathname, ACE_TEXT ("(shr.o)"));
open_mode |= RTLD_MEMBER;
if (ACE::debug ())
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("ACE (%P|%t) DLL_Handle::open ")
ACE_TEXT ("(\"%s\", 0x%x) -> %s: %s\n"),
aix_pathname,
open_mode,
ACE_TEXT ((this->handle_ != ACE_SHLIB_INVALID_HANDLE)
? "succeeded"
: "failed"),
this->error()->c_str()));
}
this->handle_ = ACE_OS::dlopen (aix_pathname, open_mode);
if (this->handle_ != ACE_SHLIB_INVALID_HANDLE)
break;
// If errno is ENOENT we just skip over this one, anything
// else - like an undefined symbol, for instance
// must be flagged here or the next error will mask it.
//
// @TODO: If we've found our DLL _and_ it's broken,
// should we continue at all?
if (ACE::debug () && (errno != 0) && (errno != ENOENT))
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE (%P|%t) DLL_Handle::open ")
ACE_TEXT ("(\'%s\') failed, errno=")
ACE_TEXT ("%d: %s\n"),
name->c_str (),
errno,
this->error ()->c_str ()));
}
#endif /* AIX */
name_iter.advance ();
}
if (this->handle_ == ACE_SHLIB_INVALID_HANDLE)
{
if (ACE::debug ())
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ACE (%P|%t) DLL_Handle::open (\"%s\"): ")
ACE_TEXT ("Invalid handle error: %s\n"),
this->dll_name_,
this->error ()->c_str ()));
return -1;
}
}
}
++this->refcount_;
if (ACE::debug ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("ACE (%P|%t) DLL_Handle::open - %s (%d), refcount=%d\n"),
this->dll_name_,
this->handle_,
this->refcount_));
return 0;
}
CORBA::OperationDef_ptr
TAO_InterfaceDef_i::create_operation_i (const char *id,
const char *name,
const char *version,
CORBA::IDLType_ptr result,
CORBA::OperationMode mode,
const CORBA::ParDescriptionSeq ¶ms,
const CORBA::ExceptionDefSeq &exceptions,
const CORBA::ContextIdSeq &contexts)
{
// This will throw an exception if a name clash is found.
// create_common() will check for all other errors.
this->check_inherited (name,
CORBA::dk_Operation);
TAO_Container_i::tmp_name_holder_ = name;
ACE_Configuration_Section_Key new_key;
// Common to all IR objects created in CORBA::Container.
ACE_TString path =
TAO_IFR_Service_Utils::create_common (CORBA::dk_Interface,
CORBA::dk_Operation,
this->section_key_,
new_key,
this->repo_,
id,
name,
&TAO_Container_i::same_as_tmp_name,
version,
"ops");
// Get the TypeCode for the return type.
ACE_TString result_path (TAO_IFR_Service_Utils::reference_to_path (result));
TAO_IDLType_i *result_impl =
TAO_IFR_Service_Utils::path_to_idltype (result_path,
this->repo_);
CORBA::TypeCode_var rettype =
result_impl->type_i ();
CORBA::TCKind kind = rettype->kind ();
// Oneway operations cannot have a non-void return type.
if (mode == CORBA::OP_ONEWAY && kind != CORBA::tk_void)
{
throw CORBA::BAD_PARAM (CORBA::OMGVMCID | 31, CORBA::COMPLETED_NO);
}
this->repo_->config ()->set_string_value (new_key,
"result",
result_path);
// Store the operation mode.
this->repo_->config ()->set_integer_value (new_key,
"mode",
mode);
CORBA::ULong i = 0;
// Store the operation's parameter info.
CORBA::ULong length = params.length ();
if (length > 0)
{
ACE_Configuration_Section_Key params_key;
this->repo_->config ()->open_section (new_key,
"params",
1,
params_key);
this->repo_->config ()->set_integer_value (params_key,
"count",
length);
char *type_path = 0;
for (i = 0; i < length; ++i)
{
// Oneway operations cannot have INOUT or OUT parameters.
if (mode == CORBA::OP_ONEWAY && params[i].mode != CORBA::PARAM_IN)
{
throw CORBA::BAD_PARAM (31, CORBA::COMPLETED_NO);
}
ACE_Configuration_Section_Key param_key;
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->open_section (params_key,
stringified,
1,
param_key);
this->repo_->config ()->set_string_value (param_key,
"name",
params[i].name.in ());
type_path =
TAO_IFR_Service_Utils::reference_to_path (
params[i].type_def.in ()
);
this->repo_->config ()->set_string_value (param_key,
"type_path",
type_path);
this->repo_->config ()->set_integer_value (param_key,
"mode",
params[i].mode);
}
}
// Store the operation's exception info.
length = exceptions.length ();
if (length > 0)
{
// Oneway operations cannot throw any user exceptions.
if (mode == CORBA::OP_ONEWAY)
{
throw CORBA::BAD_PARAM (CORBA::OMGVMCID | 31, CORBA::COMPLETED_NO);
}
ACE_Configuration_Section_Key excepts_key;
this->repo_->config ()->open_section (new_key,
"excepts",
1,
excepts_key);
char *type_path = 0;
for (i = 0; i < length; ++i)
{
type_path =
TAO_IFR_Service_Utils::reference_to_path (exceptions[i]);
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->set_string_value (excepts_key,
stringified,
type_path);
}
}
// Store the operation's context info.
length = contexts.length ();
if (length > 0)
{
ACE_Configuration_Section_Key contexts_key;
this->repo_->config ()->open_section (new_key,
"contexts",
1,
contexts_key);
for (i = 0; i < length; ++i)
{
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->set_string_value (contexts_key,
stringified,
contexts[i].in ());
}
}
// Create the object reference.
CORBA::Object_var obj =
TAO_IFR_Service_Utils::create_objref (CORBA::dk_Operation,
path.c_str (),
this->repo_);
CORBA::OperationDef_var retval =
CORBA::OperationDef::_narrow (obj.in ());
return retval._retn ();
}
