void PubDriver::add_subscription ( CORBA::Long reader_id, const char * sub_addr ) { ::OpenDDS::DCPS::ReaderAssociationSeq associations; associations.length (1); associations[0].readerTransInfo.transport_id = 1; // TBD - not right OpenDDS::DCPS::NetworkAddress network_order_address(sub_addr); ACE_OutputCDR cdr; cdr << network_order_address; size_t len = cdr.total_length (); associations[0].readerTransInfo.data = OpenDDS::DCPS::TransportInterfaceBLOB (len, len, (CORBA::Octet*)(cdr.buffer ())); associations[0].readerId = reader_id; associations[0].subQos = TheServiceParticipant->initial_SubscriberQos (); associations[0].readerQos = TheServiceParticipant->initial_DataReaderQos (); OpenDDS::DCPS::RepoId pub_id = foo_datawriter_servant_->get_publication_id(); datawriter_servant_->add_associations (pub_id, associations); }
bool MulticastTransport::connection_info_i(TransportLocator& info) const { NetworkAddress network_address(this->config_i_->group_address_); ACE_OutputCDR cdr; cdr << network_address; const CORBA::ULong len = static_cast<CORBA::ULong>(cdr.total_length()); char* buffer = const_cast<char*>(cdr.buffer()); // safe info.transport_type = "multicast"; info.data = TransportBLOB(len, len, reinterpret_cast<CORBA::Octet*>(buffer)); return true; }
void SubDriver::run() { // Set up the publications. OpenDDS::DCPS::AssociationData publications[1]; publications[0].remote_id_ = this->pub_id_; publications[0].remote_data_.transport_id = 2; // TBD later - wrong OpenDDS::DCPS::NetworkAddress network_order_address(this->pub_addr_str_); ACE_OutputCDR cdr; cdr << network_order_address; size_t len = cdr.total_length (); publications[0].remote_data_.data = OpenDDS::DCPS::TransportInterfaceBLOB (len, len, (CORBA::Octet*)(cdr.buffer ())); // Write a file so that test script knows we're ready FILE * file = ACE_OS::fopen ("subready.txt", "w"); ACE_OS::fprintf (file, "Ready\n"); ACE_OS::fclose (file); this->subscriber_.init(ALL_TRAFFIC, this->sub_id_, 1, /* size of publications array */ publications, this->num_msgs_); // Wait until we receive our expected message from the remote // publisher. For this test, we should wait until we receive the // "Hello World!" message that we expect. Then this program // can just shutdown. while (this->subscriber_.received_test_message() == 0) { ACE_OS::sleep(1); } // Tear-down the entire Transport Framework. TheTransportFactory->release(); TheServiceParticipant->shutdown(); }
size_t UdpInst::populate_locator(OpenDDS::DCPS::TransportLocator& info) const { if (this->local_address_ != ACE_INET_Addr()) { NetworkAddress network_address(this->local_address_, this->local_address_.is_any()); ACE_OutputCDR cdr; cdr << network_address; const CORBA::ULong len = static_cast<CORBA::ULong>(cdr.total_length()); char* buffer = const_cast<char*>(cdr.buffer()); // safe info.transport_type = "udp"; info.data = TransportBLOB(len, len, reinterpret_cast<CORBA::Octet*>(buffer)); return 1; } else { return 0; } }
/** * UDPGenerator::gloveDgramWrite * * @param remotehost * @param remoteport * @param glovedata * * @return */ int UDPGenerator::gloveDgramWrite( const ACE_TCHAR * remotehost, u_short remoteport, const DataGloveData &glovedata) { ACE_DEBUG ((LM_DEBUG, "Sender::initiate_write called\n")); const size_t max_payload_size = 4 //boolean alignment flag + 4 //payload length + glovedata.length // Data Glove data length + ACE_CDR::MAX_ALIGNMENT; //pading // Rescuer header u_short myid = htons(5); u_short mysize = htons(max_payload_size); ACE_Message_Block* rescuerheader= 0; ACE_NEW_RETURN(rescuerheader, ACE_Message_Block(4), -1); rescuerheader->copy((const char *)&myid, 2); rescuerheader->copy((const char *)&mysize, 2); // My DGS stuff (header and payload) ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8); header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER); header << ACE_CDR::ULong(length); // DGS Payload ACE_OutputCDR payload (max_payload_size); payload << glovedata; ACE_CDR::ULong length = payload.total_length(); iovec iov[3]; iov[0].iov_base = rescuerheader->rd_ptr(); iov[0].iov_len = 4; iov[1].iov_base = header.begin()->rd_ptr(); iov[1].iov_len = HEADER_SIZE; iov[2].iov_base = payload.begin()->rd_ptr(); iov[2].iov_len = length; ACE_INET_Addr serverAddr(remoteport, remotehost); return sockDgram_.send(iov,3, serverAddr ); }
bool TcpTransport::connection_info_i(TransportLocator& local_info) const { DBG_ENTRY_LVL("TcpTransport", "connection_info_i", 6); VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport public address str %C\n", this->tcp_config_->get_public_address().c_str()), 2); // Get the public address string from the inst (usually the local address) NetworkAddress network_order_address(this->tcp_config_->get_public_address()); ACE_OutputCDR cdr; cdr << network_order_address; const CORBA::ULong len = static_cast<CORBA::ULong>(cdr.total_length()); char* buffer = const_cast<char*>(cdr.buffer()); // safe local_info.transport_type = "tcp"; local_info.data = TransportBLOB(len, len, reinterpret_cast<CORBA::Octet*>(buffer)); return true; }
//FUZZ: disable check_for_lack_ACE_OS int send (const ACE_Log_Record &log_record) { //FUZZ: enable check_for_lack_ACE_OS // Serialize the log record using a CDR stream, allocate // enough space for the complete <ACE_Log_Record>. const size_t max_payload_size = 4 // type() + 8 // timestamp + 4 // process id + 4 // data length + ACE_Log_Record::MAXLOGMSGLEN // data + ACE_CDR::MAX_ALIGNMENT; // padding; // Insert contents of <log_record> into payload stream. ACE_OutputCDR payload (max_payload_size); payload << log_record; // Get the number of bytes used by the CDR stream. ACE_CDR::ULong length = payload.total_length (); // Send a header so the receiver can determine the byte // order and size of the incoming CDR stream. ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8); header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER); // Store the size of the payload that follows header << ACE_CDR::ULong (length); // Use an iovec to send both buffer and payload simultaneously. iovec iov[2]; iov[0].iov_base = header.begin ()->rd_ptr (); iov[0].iov_len = 8; iov[1].iov_base = payload.begin ()->rd_ptr (); iov[1].iov_len = length; // Send header and payload efficiently using "gather-write". return logging_peer_.sendv_n (iov, 2); }
ssize_t ACE_Log_Msg_IPC::log (ACE_Log_Record &log_record) { // Serialize the log record using a CDR stream, allocate enough // space for the complete <ACE_Log_Record>. size_t const max_payload_size = 4 // type + 4 // pid + 12 // timestamp + 4 // process id + 4 // data length #if defined (ACE_USES_WCHAR) + (log_record.msg_data_len () * ACE_OutputCDR::wchar_maxbytes()) // message #else + log_record.msg_data_len () // message #endif + ACE_CDR::MAX_ALIGNMENT; // padding; // Insert contents of <log_record> into payload stream. ACE_OutputCDR payload (max_payload_size); payload << log_record; // Get the number of bytes used by the CDR stream. If it becomes desireable // to support payloads more than 4GB, this field will need to be changed // to a 64-bit value. ACE_CDR::ULong length = ACE_Utils::truncate_cast<ACE_CDR::ULong> (payload.total_length ()); // Send a header so the receiver can determine the byte order and // size of the incoming CDR stream. ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8); header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER); // Store the size of the payload that follows header << ACE_CDR::ULong (length); // Use an iovec to send both buffer and payload simultaneously. iovec iov[2]; iov[0].iov_base = header.begin ()->rd_ptr (); iov[0].iov_len = 8; iov[1].iov_base = payload.begin ()->rd_ptr (); iov[1].iov_len = length; #if defined (ACE_HAS_STREAM_PIPES) // Use the <putpmsg> API if supported to ensure correct message // queueing according to priority. ACE_Str_Buf header_msg (static_cast<void *> (header.begin ()->rd_ptr ()), static_cast<int> (8)); ACE_Str_Buf payload_msg (static_cast<void *> (payload.begin ()->rd_ptr ()), static_cast<int> (length)); return this->message_queue_.send (&header_msg, &payload_msg, static_cast<int> (log_record.priority ()), MSG_BAND); #else // We're running over sockets, so send header and payload // efficiently using "gather-write". return this->message_queue_.sendv_n (iov, 2); #endif /* ACE_HAS_STREAM_PIPES */ }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { const ACE_TCHAR *logger_host = argc > 1 ? argv[1] : LOGGER_HOST; u_short logger_port = argc > 2 ? ACE_OS::atoi (argv[2]) : LOGGER_PORT; int max_iterations = argc > 3 ? ACE_OS::atoi (argv[3]) : MAX_ITERATIONS; ACE_SOCK_Stream logger; ACE_SOCK_Connector connector; ACE_INET_Addr addr (logger_port, logger_host); if (connector.connect (logger, addr) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("open")), -1); for (int i = 0; i < max_iterations; i++) { ACE_Log_Record log_record (LM_DEBUG, ACE_OS::time ((time_t *) 0), ACE_OS::getpid ()); ACE_TCHAR buf[BUFSIZ]; ACE_OS::sprintf (buf, ACE_TEXT ("message = %d\n"), i + 1); log_record.msg_data (buf); const size_t max_payload_size = 4 // type() + 8 // timestamp + 4 // process id + 4 // data length + ACE_Log_Record::MAXLOGMSGLEN // data + ACE_CDR::MAX_ALIGNMENT; // padding; // Insert contents of <log_record> into payload stream. ACE_OutputCDR payload (max_payload_size); payload << log_record; // Get the number of bytes used by the CDR stream. ACE_CDR::ULong length = ACE_Utils::truncate_cast<ACE_CDR::ULong> (payload.total_length ()); // Send a header so the receiver can determine the byte order and // size of the incoming CDR stream. ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8); header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER); // Store the size of the payload that follows header << ACE_CDR::ULong (length); // Use an iovec to send both buffer and payload simultaneously. iovec iov[2]; iov[0].iov_base = header.begin ()->rd_ptr (); iov[0].iov_len = 8; iov[1].iov_base = payload.begin ()->rd_ptr (); iov[1].iov_len = length; if (logger.sendv_n (iov, 2) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "send"), -1); } if (logger.close () == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("close")), -1); return 0; }
void SubDriver::run() { DBG_ENTRY_LVL("SubDriver", "run", 6); VDBG((LM_DEBUG, "(%P|%t) DBG: " "Initialize our SimpleSubscriber object.\n")); this->reader_.enable_transport(false /*reliable*/, false /*durable*/); // Write a file so that test script knows we're ready FILE * file = ACE_OS::fopen ("subready.txt", ACE_TEXT("w")); ACE_OS::fprintf (file, "Ready\n"); ACE_OS::fclose (file); VDBG((LM_DEBUG, "(%P|%t) DBG: Create the 'publications'.\n")); // Set up the publication. OpenDDS::DCPS::AssociationData publication; publication.remote_id_ = this->pub_id_; publication.remote_reliable_ = true; publication.remote_data_.length(1); if (shmem_) { publication.remote_data_[0].transport_type = "shmem"; std::ofstream ofs("sub-pid.txt"); ofs << ACE_OS::getpid() << std::endl; ofs.close(); for (ACE_stat filestat; -1 == ACE_OS::stat("pub-pid.txt", &filestat); ACE_OS::sleep(1)) {/*empty loop*/} std::ifstream ifs("pub-pid.txt"); std::string pid; getline(ifs, pid); std::string str = OpenDDS::DCPS::get_fully_qualified_hostname() + '\0' + "OpenDDS-" + pid + "-shmem1"; publication.remote_data_[0].data.length(static_cast<CORBA::ULong>(str.size())); std::memcpy(publication.remote_data_[0].data.get_buffer(), str.c_str(), str.size()); } else { // tcp publication.remote_data_[0].transport_type = "tcp"; OpenDDS::DCPS::NetworkAddress network_order_address( ACE_TEXT_ALWAYS_CHAR(this->pub_addr_str_.c_str())); ACE_OutputCDR cdr; cdr << network_order_address; CORBA::ULong len = static_cast<CORBA::ULong>(cdr.total_length()); publication.remote_data_[0].data = OpenDDS::DCPS::TransportBLOB(len, len, (CORBA::Octet*)(cdr.buffer())); } this->reader_.init(publication, this->num_msgs_); VDBG((LM_DEBUG, "(%P|%t) DBG: " "Ask the SimpleSubscriber object if it has received what, " "it expected. If not, sleep for 1 second, and ask again.\n")); // Wait until we receive our expected message from the remote // publisher. For this test, we should wait until we receive the // "Hello World!" message that we expect. Then this program // can just shutdown. while (this->reader_.received_test_message() == 0) { ACE_OS::sleep(1); } this->reader_.print_time(); if (shmem_) { ACE_OS::unlink("sub-pid.txt"); } VDBG((LM_DEBUG, "(%P|%t) DBG: " "The SimpleSubscriber object has received what it expected. " "Release TheTransportFactory - causing all TransportImpl " "objects to be shutdown().\n")); this->reader_.disassociate(this->pub_id_); TheServiceParticipant->shutdown(); VDBG((LM_DEBUG, "(%P|%t) DBG: " "TheTransportFactory has finished releasing.\n")); }
void PubDriver::run() { DBG_ENTRY_LVL("PubDriver","run",6); VDBG((LM_DEBUG, "(%P|%t) DBG: " "Initialize our SimplePublisher object.\n")); this->writer_.enable_transport(false /*reliable*/, false /*durable*/); VDBG((LM_DEBUG, "(%P|%t) DBG: Create the 'subscriptions'.\n")); // Set up the subscription. OpenDDS::DCPS::AssociationData subscription; subscription.remote_id_ = this->sub_id_; subscription.remote_reliable_ = true; subscription.remote_data_.length(1); if (shmem_) { subscription.remote_data_[0].transport_type = "shmem"; std::ofstream ofs("pub-pid.txt"); ofs << ACE_OS::getpid() << std::endl; ofs.close(); for (ACE_stat filestat; -1 == ACE_OS::stat("sub-pid.txt", &filestat); ACE_OS::sleep(1)) {/*empty loop*/} std::ifstream ifs("sub-pid.txt"); std::string pid; getline(ifs, pid); std::string str = OpenDDS::DCPS::get_fully_qualified_hostname() + '\0' + "OpenDDS-" + pid + "-shmem1"; subscription.remote_data_[0].data.length(static_cast<CORBA::ULong>(str.size())); std::memcpy(subscription.remote_data_[0].data.get_buffer(), str.c_str(), str.size()); } else { // tcp subscription.remote_data_[0].transport_type = "tcp"; OpenDDS::DCPS::NetworkAddress network_order_address( ACE_TEXT_ALWAYS_CHAR(this->sub_addr_str_.c_str())); ACE_OutputCDR cdr; cdr << network_order_address; CORBA::ULong len = static_cast<CORBA::ULong>(cdr.total_length()); subscription.remote_data_[0].data = OpenDDS::DCPS::TransportBLOB(len, len, (CORBA::Octet*)(cdr.buffer())); } this->writer_.init(subscription); // Wait for a fully association establishment and then start sending samples. ACE_OS::sleep(2); VDBG((LM_DEBUG, "(%P|%t) DBG: " "Run our SimplePublisher object.\n")); this->writer_.run(this->num_msgs_, this->msg_size_); VDBG((LM_DEBUG, "(%P|%t) DBG: " "Ask the SimplePublisher object if it is done running. " "If not, sleep for 1 second, and ask again.\n")); while (this->writer_.delivered_test_message() == 0) { ACE_OS::sleep(1); } if (shmem_) { for (ACE_stat filestat; 0 == ACE_OS::stat("sub-pid.txt", &filestat); ACE_OS::sleep(1)) {/*empty loop*/} } VDBG((LM_DEBUG, "(%P|%t) DBG: " "The SimplePublisher object is done running. " "Release TheTransportFactory - causing all TransportImpl " "objects to be shutdown().\n")); this->writer_.disassociate(this->sub_id_); TheServiceParticipant->shutdown(); VDBG((LM_DEBUG, "(%P|%t) DBG: " "TheTransportFactory has finished releasing.\n")); }
void SubDriver::run() { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%P|%t) SubDriver::run, ") ACE_TEXT(" Wait for %s. \n"), pub_id_fname_.c_str ())); PublicationIds ids; // Wait for the publication id file created by the publisher. while (1) { FILE* fp = ACE_OS::fopen (pub_id_fname_.c_str (), ACE_TEXT("r")); if (fp == 0) { ACE_OS::sleep (1); } else { // This could be made cleaner by losing the old C-style I/O. ::OpenDDS::DCPS::PublicationId pub_id = OpenDDS::DCPS::GUID_UNKNOWN; char charBuffer[64]; while (fscanf (fp, "%s\n", &charBuffer[0]) != EOF) { std::stringstream buffer( charBuffer); buffer >> pub_id; ids.push_back (pub_id); std::stringstream idBuffer; idBuffer << pub_id; ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%P|%t) SubDriver::run, ") ACE_TEXT(" Got from %s: pub_id=%C. \n"), pub_id_fname_.c_str (), buffer.str().c_str())); } ACE_OS::fclose (fp); break; } } CORBA::Object_var object = orb_->string_to_object (pub_driver_ior_.c_str ()); pub_driver_ = ::Test::TestPubDriver::_narrow (object.in ()); TEST_CHECK (!CORBA::is_nil (pub_driver_.in ())); size_t num_publications = ids.size (); // Set up the publications. OpenDDS::DCPS::AssociationData* publications = new OpenDDS::DCPS::AssociationData[num_publications]; for (size_t i = 0; i < num_publications; i ++) { publications[i].remote_id_ = ids[i]; publications[i].remote_data_.transport_id = ALL_TRAFFIC; // TBD later - wrong publications[i].remote_data_.publication_transport_priority = 0; OpenDDS::DCPS::NetworkAddress network_order_address(this->pub_addr_str_); ACE_OutputCDR cdr; cdr << network_order_address; size_t len = cdr.total_length (); publications[i].remote_data_.data = OpenDDS::DCPS::TransportInterfaceBLOB (len, len, (CORBA::Octet*)(cdr.buffer ())); } this->subscriber_.init(ALL_TRAFFIC, this->sub_id_, num_publications, publications, receive_delay_msec_); delete [] publications; while (this->subscriber_.received_test_message() != num_writes_) { ACE_OS::sleep(1); } pub_driver_->shutdown (); // Sleep before release transport so the connection will not go away. // This would avoid the problem of publisher sendv failure due to lost // connection during the shutdown period. ACE_OS::sleep (5); OpenDDS::DCPS::WriterIdSeq writers; writers.length(num_publications); for (size_t i = 0; i < num_publications; ++i) { writers[i] = ids[i]; } this->subscriber_.remove_associations(num_publications, writers.get_buffer(), this->sub_id_); // Tear-down the entire Transport Framework. TheTransportFactory->release(); TheServiceParticipant->shutdown(); }