作者：asdlei0
项目：AC
int
Peer_Handler::transmit_stdin (void)
{
// If return value is -1, then first_time_ must be reset to 1.
int result = 0;
if (this->connection_id_ != -1)
{
ACE_Message_Block *mb = 0;
ACE_NEW_RETURN (mb,
ACE_Message_Block (sizeof (Event)),
-1);
// Cast the message block payload into an <Event> pointer.
Event *event = (Event *) mb->rd_ptr ();
ssize_t n = ACE_OS::read (ACE_STDIN,
event->data_,
sizeof event->data_);
switch (n)
{
case 0:
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("stdin closing down\n")));
// Take stdin out of the ACE_Reactor so we stop trying to
// send events.
ACE_Reactor::instance ()->remove_handler
(ACE_STDIN,
ACE_Event_Handler::DONT_CALL | ACE_Event_Handler::READ_MASK);
mb->release ();
result = 0; //
break;
/* NOTREACHED */
case -1:
mb->release ();
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("read")));
result = 0; //
break;
/* NOTREACHED */
default:
// Do not return directly, save the return value.
result = this->transmit (mb, n, ROUTING_EVENT);
break;
/* NOTREACHED */
}
// Do not return at here, but at exit of function.
/*return 0;*/
}
else
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Must transmit over an opened channel.\n")));
result = -1; // Save return value at here, return at exit of function.
}
// If transmit error, the stdin-thread will be cancelled, so should
// reset first_time_ to 1, which will register_stdin_handler again.
if (result == -1)
first_time_ = 1;
return result;
}
作者：eSD
项目：eSDKClient_Soultio
template <class HANDLER> void
ACE_Asynch_Connector<HANDLER>::parse_address (const ACE_Asynch_Connect::Result &result,
ACE_INET_Addr &remote_address,
ACE_INET_Addr &local_address)
{
#if defined (ACE_HAS_IPV6)
// Getting the addresses.
sockaddr_in6 local_addr;
sockaddr_in6 remote_addr;
#else
// Getting the addresses.
sockaddr_in local_addr;
sockaddr_in remote_addr;
#endif /* ACE_HAS_IPV6 */
// Get the length.
int local_size = sizeof (local_addr);
int remote_size = sizeof (remote_addr);
// Get the local address.
if (ACE_OS::getsockname (result.connect_handle (),
reinterpret_cast<sockaddr *> (&local_addr),
&local_size) < 0)
ACE_ERROR ((LM_ERROR,
ACE_TEXT("%p\n"),
ACE_TEXT("ACE_Asynch_Connector::<getsockname> failed")));
// Get the remote address.
if (ACE_OS::getpeername (result.connect_handle (),
reinterpret_cast<sockaddr *> (&remote_addr),
&remote_size) < 0)
ACE_ERROR ((LM_ERROR,
ACE_TEXT("%p\n"),
ACE_TEXT("ACE_Asynch_Connector::<getpeername> failed")));
// Set the addresses.
local_address.set (reinterpret_cast<sockaddr_in *> (&local_addr),
local_size);
remote_address.set (reinterpret_cast<sockaddr_in *> (&remote_addr),
remote_size);
#if 0
// @@ Just debugging.
char local_address_buf [BUFSIZ];
char remote_address_buf [BUFSIZ];
if (local_address.addr_to_string (local_address_buf,
sizeof local_address_buf) == -1)
ACE_ERROR ((LM_ERROR,
"Error:%m:can't obtain local_address's address string"));
ACE_DEBUG ((LM_DEBUG,
"ACE_Asynch_Connector<HANDLER>::parse_address : "
"Local address %s\n",
local_address_buf));
if (remote_address.addr_to_string (remote_address_buf,
sizeof remote_address_buf) == -1)
ACE_ERROR ((LM_ERROR,
"Error:%m:can't obtain remote_address's address string"));
ACE_DEBUG ((LM_DEBUG,
"ACE_Asynch_Connector<HANDLER>::parse_address : "
"Remote address %s\n",
remote_address_buf));
#endif /* 0 */
return;
}
作者：asdlei0
项目：AC
static bool
timeout_test (void)
{
bool status = true;
SYNCH_QUEUE mq;
MyTask task1;
task1.create_reactor ();
task1.start (1);
TestHandler test_handler (task1.get_reactor (), mq);
// The reactor of taks1 that uses a hrtimer will trigger a timeout in
// 5 seconds which will enqueue a message block in the queue. At the
// same moment we calculate a timeout for the dequeue operation for
// 3 seconds in the future. Than we set the system time 4 seconds back.
// The condition should timeout because the queue is empty and the trigger
// only fires after the condition has timed out.
// Next we start another dequeue for 3 seconds in the future which should
// return before timing out because by then the trigger should have fired.
// In case of using regular system time policy for message queue and
// dequeue timeouts the first dequeue would not have timed out because
// between calculating the timeout and starting the dequeue the system time
// shifted back 4 sec causing the trigger to fire before the timeout elapsed.
// In case timeshifting does not work because of priority problems or such
// the test should succeed.
if (!test_handler.trigger_in (ACE_Time_Value (5, 0)))
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Unable to schedule trigger.\n"),
false);
if (!mq.is_empty ())
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("New queue is not empty!\n")));
status = false;
}
else
{
ACE_Message_Block *b;
ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv;
tv = (tv.now () + ACE_Time_Value (3,0)); // Now (monotonic time) + 3 sec
// shift back in time 4 sec
set_system_time (ACE_OS::gettimeofday () - ACE_Time_Value (4, 0));
if (mq.dequeue_head (b, &tv) != -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Dequeued before timeout elapsed!\n")));
status = false;
}
else if (errno != EWOULDBLOCK)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("Dequeue timeout should be EWOULDBLOCK, got")));
status = false;
}
else
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("First dequeue timed out: OK\n")));
tv = (tv.now () + ACE_Time_Value (3,0)); // Now (monotonic time) + 3 sec
if (mq.dequeue_head (b, &tv) != -1)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Second dequeue succeeded: OK\n")));
delete b;
}
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Second dequeue timed out!\n")));
status = false;
}
}
// restore time
set_system_time (ACE_OS::gettimeofday () + ACE_Time_Value (4, 0));
}
ACE_DEBUG((LM_INFO,
"(%P|%t) Asking worker thread to finish.\n"));
task1.stop ();
ACE_Thread_Manager::instance ()->wait ();
return status;
}
作者：CCJ
项目：ATC
void
Worker::setup (void)
{
// Make sure we have a connection to the server using the test
// protocol.
this->policy_manager_->set_policy_overrides (this->test_protocol_policy_,
CORBA::SET_OVERRIDE);
// Since the network maybe unavailable temporarily, make sure to try
// for a few times before giving up.
for (CORBA::ULong j = 0;;)
{
try
{
// Send a message to ensure that the connection is setup.
this->test_->oneway_sync ();
break;
}
catch (const CORBA::TRANSIENT &)
{
++j;
if (j < this->number_of_connection_attempts_)
{
ACE_OS::sleep (1);
continue;
}
}
ACE_ERROR ((LM_ERROR,
"Cannot setup test protocol\n"));
ACE_OS::exit (-1);
}
const char *test_protocol = 0;
if (this->test_protocol_tag_ == IOP::TAG_INTERNET_IOP)
test_protocol = "IIOP";
else if (this->test_protocol_tag_ == TAO_TAG_DIOP_PROFILE)
test_protocol = "DIOP";
else if (this->test_protocol_tag_ == TAO_TAG_SCIOP_PROFILE)
test_protocol = "SCIOP";
// Use IIOP for setting up the test since the test protocol maybe
// unreliable.
this->policy_manager_->set_policy_overrides (this->base_protocol_policy_,
CORBA::SET_OVERRIDE);
// Since the network maybe unavailable temporarily, make sure to try
// for a few times before giving up.
for (CORBA::ULong k = 0;;)
{
try
{
// Let the server know what to expect..
this->test_->start_test (this->session_id_,
test_protocol,
this->invocation_rate_,
this->message_size_,
this->iterations_);
break;
}
catch (const CORBA::TRANSIENT &)
{
ACE_OS::sleep (1);
if (k < this->number_of_connection_attempts_)
{
ACE_OS::sleep (1);
continue;
}
}
ACE_ERROR ((LM_ERROR,
"Cannot setup base protocol\n"));
ACE_OS::exit (-1);
}
return;
}
作者：asdlei0
项目：AC
int
ClientApp::run (int argc, ACE_TCHAR* argv[])
{
CORBA::ORB_var orb
= CORBA::ORB_init (argc, argv);
// Parse the command-line args for this application.
// * Raises -1 if problems are encountered.
// * Returns 1 if the usage statement was explicitly requested.
// * Returns 0 otherwise.
int result = this->parse_args (argc, argv);
if (result != 0)
{
return result;
}
CORBA::Object_var obj
= orb->string_to_object(this->ior_.c_str());
if (CORBA::is_nil(obj.in()))
{
ACE_ERROR((LM_ERROR,
"(%P|%t) Failed to convert IOR string to obj ref.\n"));
throw TestException();
}
Foo_var foo = Foo::_narrow(obj.in());
if (CORBA::is_nil(foo.in()))
{
ACE_ERROR((LM_ERROR,
"(%P|%t) Failed to narrow obj ref to Foo interface.\n"));
throw TestException();
}
// Create the callback object using the child poa with the custom
// strategy.
obj = orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil(obj.in()))
{
ACE_ERROR((LM_ERROR,
"(%P|%t) Failed to resolve initial ref for 'RootPOA'.\n"));
throw TestException();
}
PortableServer::POA_var root_poa
= PortableServer::POA::_narrow(obj.in());
if (CORBA::is_nil(root_poa.in()))
{
ACE_ERROR((LM_ERROR,
"(%P|%t) Failed to narrow obj ref to POA interface.\n"));
throw TestException();
}
PortableServer::POAManager_var poa_manager
= root_poa->the_POAManager();
// Create the child POA.
CORBA::PolicyList policies(0);
policies.length(0);
PortableServer::POA_var child_poa
= root_poa->create_POA("ChildPoa",
poa_manager.in(),
policies);
if (CORBA::is_nil(child_poa.in()))
{
ACE_ERROR((LM_ERROR, "(%P|%t) ERROR [ServerApp::run()]: "
"Failed to create the child POA.\n"));
throw TestException();
}
// Create the thread pool servant dispatching strategy object, and
// hold it in a (local) smart pointer variable.
TAO_Intrusive_Ref_Count_Handle<TAO::CSD::TP_Strategy> csd_tp_strategy =
new TAO::CSD::TP_Strategy();
csd_tp_strategy->set_num_threads(1);
// Tell the strategy to apply itself to the child poa.
if (csd_tp_strategy->apply_to(child_poa.in()) == false)
{
ACE_ERROR((LM_ERROR, "(%P|%t) ERROR [ServerApp::run()]: "
"Failed to apply custom dispatching strategy to child poa.\n"));
throw TestException();
}
// Create the servant object.
Callback_i* servant = new Callback_i ();
// local smart pointer variable to deal with releasing the reference
// to the servant object when the smart pointer object falls out of scope.
PortableServer::ServantBase_var owner_transfer(servant);
// Activate the servant using the Child POA.
PortableServer::ObjectId_var oid
= child_poa->activate_object(servant);
//.........这里部分代码省略.........
作者：binghuo36
项目：BaseLa
void
Receiver::open (ACE_HANDLE handle,
ACE_Message_Block &message_block)
{
ACE_DEBUG ((LM_DEBUG,
"%N:%l:Receiver::open called\n"));
// New connection, so initiate stuff.
// Cache the new connection
this->handle_ = handle;
// File offset starts at zero
this->file_offset_ = 0;
// Open dump file (in OVERLAPPED mode)
this->dump_file_ = ACE_OS::open (dump_file,
O_CREAT | O_RDWR | O_TRUNC | \
FILE_FLAG_OVERLAPPED);
if (this->dump_file_ == ACE_INVALID_HANDLE)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"ACE_OS::open"));
return;
}
// Initiate <ACE_Asynch_Write_File>.
if (this->wf_.open (*this,
this->dump_file_) == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"ACE_Asynch_Write_File::open"));
return;
}
// Initiate <ACE_Asynch_Read_Stream>.
if (this->rs_.open (*this, this->handle_) == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"ACE_Asynch_Read_Stream::open"));
return;
}
// Fake the result and make the <handle_read_stream> get
// called. But, not, if there is '0' is transferred.
if (message_block.length () != 0)
{
// Duplicate the message block so that we can keep it around.
ACE_Message_Block &duplicate =
*message_block.duplicate ();
// Fake the result so that we will get called back.
ACE_Asynch_Read_Stream_Result_Impl *fake_result =
ACE_Proactor::instance ()->create_asynch_read_stream_result (this->proxy (),
this->handle_,
duplicate,
initial_read_size,
0,
ACE_INVALID_HANDLE,
0,
0);
size_t bytes_transferred = message_block.length ();
// <complete> for Accept would have already moved the <wr_ptr>
// forward. Update it to the beginning position.
duplicate.wr_ptr (duplicate.wr_ptr () - bytes_transferred);
// This will call the callback.
fake_result->complete (message_block.length (),
1,
0);
// Zap the fake result.
delete fake_result;
}
else
// Otherwise, make sure we proceed. Initiate reading the socket
// stream.
if (this->initiate_read_stream () == -1)
return;
}
作者：asdlei0
项目：AC
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
const char *location1 = "MyLocation 1";
const char *location2 = "MyLocation 2";
const char *location3 = "MyLocation 3";
const char *location4 = "MyLocation 4";
const char *location5 = "MyLocation 5";
const char *location6 = "MyLocation 6";
LB_server lb_server (argc, argv);
if (lb_server.start_orb_and_poa () == -1)
return 1;
if (parse_args (argc, argv) == -1)
return 1;
if (server_id == 1 && lb_server.create_object_group () == -1)
return 1;
else if (lb_server.get_object_group () == -1)
return 1;
const char ** location = 0;
switch (server_id)
{
case 1:
location = &location1;
break;
case 2:
location = &location2;
break;
case 3:
location = &location3;
break;
case 4:
location = &location4;
break;
case 5:
location = &location5;
break;
case 6:
location = &location6;
break;
}
Basic *basic_servant;
ACE_NEW_RETURN (basic_servant,
Basic (lb_server.object_group (),
lb_server.load_manager (),
lb_server.orb (),
*location,
server_id),
1);
PortableServer::ServantBase_var owner_transfer(basic_servant);
if (lb_server.register_servant (basic_servant, *location) == -1)
{
(void) lb_server.destroy ();
return 1;
}
if (server_id == 2)
{
Basic *direct_basic_servant = 0;
ACE_NEW_RETURN (direct_basic_servant,
Basic (server_id),
1);
PortableServer::ServantBase_var owner_transfer(direct_basic_servant);
Test::Basic_var direct_basic =
direct_basic_servant->_this ();
CORBA::String_var ior =
lb_server.orb ()->object_to_string (direct_basic.in ());
FILE *output_file =
ACE_OS::fopen (direct_obj_file, "w");
if (output_file == 0)
{
ACE_ERROR ((LM_ERROR,
"Cannot open output file(%s) for writing IOR:", direct_obj_file));
if (lb_server.destroy () == -1)
return 1;
}
ACE_OS::fprintf (output_file, "%s", ior.in());
ACE_OS::fclose (output_file);
}
// ACE_OS::sleep (1000);
lb_server.orb ()->run ();
//.........这里部分代码省略.........
作者：suiye22
项目：ace-linu
//.........这里部分代码省略.........
case '\xb2':
case '\xb3':
case '\xb4':
case '\xb5':
case '\xb6':
case '\xb7':
case '\xb8':
case '\xb9':
case '\xba':
case '\xbb':
case '\xbc':
case '\xbd':
case '\xbe':
case '\xbf':
case '\xc0':
case '\xc1':
case '\xc2':
case '\xc3':
case '\xc4':
case '\xc5':
case '\xc6':
case '\xc7':
case '\xc8':
case '\xc9':
case '\xca':
case '\xcb':
case '\xcc':
case '\xcd':
case '\xce':
case '\xcf':
case '\xd0':
case '\xd1':
case '\xd2':
case '\xd3':
case '\xd4':
case '\xd5':
case '\xd6':
case '\xd7':
case '\xd8':
case '\xd9':
case '\xda':
case '\xdb':
case '\xdc':
case '\xdd':
case '\xde':
case '\xdf':
case '\xe0':
case '\xe1':
case '\xe2':
case '\xe3':
case '\xe4':
case '\xe5':
case '\xe6':
case '\xe7':
case '\xe8':
case '\xe9':
case '\xea':
case '\xeb':
case '\xec':
case '\xed':
case '\xee':
case '\xef':
case '\xf0':
case '\xf1':
case '\xf2':
case '\xf3':
case '\xf4':
case '\xf5':
case '\xf6':
case '\xf7':
case '\xf8':
case '\xf9':
case '\xfa':
case '\xfb':
case '\xfc':
case '\xfd':
case '\xfe':
case '\xff':
{
// Test works
retval = 0;
}
break;
}
if (retval != 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("ERROR: Switch doesn't worked as expected\n")));
}
else
{
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("Switch worked as expected\n")));
}
ACE_END_TEST;
return retval;
}
作者：INMarku
项目：ATC
//.........这里部分代码省略.........
fresulta.get (resulta);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) result(%u) a %u\n"),
count,
(u_int) resulta));
}
count = 0;
while (fsetb.next_readable (fresultb))
{
fresultb.get (resultb);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) result(%u) b %u\n"),
count,
(u_int) resultb));
}
count = 0;
while (fsetc.next_readable (fresultc))
{
fresultc.get (resultc);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) result(%u) c %u\n"),
count,
(u_int) resultc));
}
count = 0;
while (fsetd.next_readable (fresultd))
{
fresultd.get (resultd);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) result(%u) d %u\n"),
count,
(u_int) resultd));
}
const ACE_TCHAR *name = 0;
count = 0;
while (fsetname.next_readable (fname))
{
fname.get (name);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) result(%u) name %s\n"),
count,
name));
}
if (fseta.is_empty ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) wow.. set a is empty.....\n")));
if (fsetb.is_empty ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) wow.. set b is empty.....\n")));
if (fsetc.is_empty ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) wow.. set c is empty.....\n")));
if (fsetd.is_empty ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) wow.. set d is empty.....\n")));
if (fsetname.is_empty ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) wow.. set name is empty.....\n")));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) task_count %d\n"),
task_count.value () ));
// Close things down.
andres->end ();
peter->end ();
helmut->end ();
matias->end ();
ACE_Thread_Manager::instance ()->wait ();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) task_count %d\n"),
task_count.value () ));
delete andres;
delete peter;
delete helmut;
delete matias;
#else
ACE_ERROR ((LM_INFO,
ACE_TEXT ("threads not supported on this platform\n")));
#endif /* ACE_HAS_THREADS */
ACE_END_TEST;
return 0;
}
作者：esohn
项目：ATC
int
Logging_Handler::handle_input (ACE_HANDLE)
{
ACE_Log_Record log_record;
// We need to use the old two-read trick here since TCP sockets
// don't support framing natively. Allocate a message block for the
// payload; initially at least large enough to hold the header, but
// needs some room for alignment.
ACE_Message_Block *payload_p = 0;
ACE_Message_Block *header_p = 0;
ACE_NEW_RETURN (header_p,
ACE_Message_Block (ACE_DEFAULT_CDR_BUFSIZE),
-1);
auto_ptr <ACE_Message_Block> header (header_p);
// Align the Message Block for a CDR stream
ACE_CDR::mb_align (header.get ());
ACE_CDR::Boolean byte_order;
ACE_CDR::ULong length;
ssize_t count = ACE::recv_n (this->peer ().get_handle (),
header->wr_ptr (),
8);
switch (count)
{
// Handle shutdown and error cases.
default:
case -1:
case 0:
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("server logging daemon closing down\n")));
return -1;
/* NOTREACHED */
case 8:
// Just fall through in this case..
break;
}
header->wr_ptr (8); // Reflect addition of 8 bytes.
// Create a CDR stream to parse the 8-byte header.
ACE_InputCDR header_cdr (header.get ());
// Extract the byte-order and use helper methods to disambiguate
// octet, booleans, and chars.
header_cdr >> ACE_InputCDR::to_boolean (byte_order);
// Set the byte-order on the stream...
header_cdr.reset_byte_order (byte_order);
// Extract the length
header_cdr >> length;
ACE_NEW_RETURN (payload_p,
ACE_Message_Block (length),
-1);
auto_ptr <ACE_Message_Block> payload (payload_p);
// Ensure there's sufficient room for log record payload.
ACE_CDR::grow (payload.get (), 8 + ACE_CDR::MAX_ALIGNMENT + length);
// Use <recv_n> to obtain the contents.
if (ACE::recv_n (this->peer ().get_handle (),
payload->wr_ptr (),
length) <= 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("recv_n()")));
return -1;
}
payload->wr_ptr (length); // Reflect additional bytes
ACE_InputCDR payload_cdr (payload.get ());
payload_cdr.reset_byte_order (byte_order);
payload_cdr >> log_record; // Finally extract the <ACE_log_record>.
log_record.length (length);
log_record.print (ACE_TEXT_CHAR_TO_TCHAR (this->peer_name_), 1, stderr);
return 0;
}
作者：esohn
项目：ATC
int
Twoway_Handler::run (void)
{
// Read data from client (terminate on error).
char *request = 0;
for (;;)
{
ACE_INT32 len = 0;
if (parse_header_and_allocate_buffer (request,
&len) == -1)
return -1;
// Subtract off the sizeof the length prefix.
ssize_t r_bytes =
this->ssl_stream_ -> recv_n (request,
len - sizeof (ACE_UINT32));
if (r_bytes == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("recv")));
break;
}
else if (r_bytes == 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) reached end of input, connection ")
ACE_TEXT ("closed by client\n")));
break;
}
else if (OPTIONS::instance ()->verbose ()
&& ACE::write_n (ACE_STDOUT,
request,
r_bytes) != r_bytes)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("ACE::write_n")));
else
{
ssize_t s_bytes =
(ssize_t) OPTIONS::instance ()->reply_message_len ();
// Don't try to send more than is in the request buffer!
if (s_bytes > r_bytes)
s_bytes = r_bytes;
if (this->ssl_stream_ -> send_n (request,
s_bytes) != s_bytes)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("send_n")));
}
this->total_bytes_ += size_t (r_bytes);
this->message_count_++;
delete [] request;
request = 0;
}
delete [] request;
return 0;
}
作者：CCJ
项目：AC
int
run_main (int , ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("Monotonic_Task_Test"));
int status = 0;
# if defined (ACE_HAS_THREADS)
MyTask my_task;
if (my_task.start () == 0)
{
// shift back in time 4 sec; this would mess up timeouts if
// monotonic timer was not used
ACE_Time_Value tv_shift (4, 0);
set_system_time (ACE_OS::gettimeofday () - tv_shift);
if (my_task.put_message () == 0)
{
// task should now have finished dequeueing and started waiting for stop signal
// wait (2sec) on thread manager should timeout
// use the time policy aware gettimeofday()
// method of the task to get current time
ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv (my_task.gettimeofday ());
tv += ACE_Time_Value (2, 0);
// shift another 3 sec back in time; without monotonic timer support in
// thread manager this would mess up the timed wait
tv_shift += ACE_Time_Value (3, 0);
set_system_time (ACE_OS::gettimeofday () - ACE_Time_Value (3,0));
if (my_task.thr_mgr ()->wait (&tv) == 0)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Thread manager did not time out\n")));
status = 1;
}
else
{
ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv_now (my_task.gettimeofday ());
ACE_DEBUG ((LM_INFO, ACE_TEXT ("Thread manager timed out at %#T\n"), &tv_now));
}
}
else
status = 1;
// ok, now stop task
if (my_task.stop () != 0)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to stop task\n")));
status = 1;
}
// restore time
set_system_time (ACE_OS::gettimeofday () + tv_shift);
}
else
status = 1;
# endif /* ACE_HAS_THREADS */
ACE_END_TEST;
return status;
}
作者：CCJ
项目：AC
int
MyTask::svc (void)
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%P|%t) MyTask::svc started\n")));
// Now (according to task time policy = monotonic time)
ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv (this->gettimeofday ());
{
ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%P|%t) MyTask::svc - signalling waiter\n")));
this->cond_.signal (); // signal waiter we have started
// waiter will shift system time back 4 sec after this which would mess
// up the first wait for a message if we were not using monotonic time
}
if (!this->msg_queue ()->is_empty ())
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("New task queue is not empty!\n")));
this->status_ = -1;
}
else
{
ACE_Message_Block *b;
tv += ACE_Time_Value (3,0); // Now + 3 sec
if (this->getq (b, &tv) != -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Dequeued before timeout elapsed!\n")));
this->status_ = -1;
}
else if (errno != EWOULDBLOCK)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("Dequeue timeout should be EWOULDBLOCK, got")));
this->status_ = -1;
}
else
{
ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv_now (this->gettimeofday ());
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("First getq timed out at %#T (timeout was %#T)\n"), &tv_now, &tv));
tv = this->gettimeofday () + ACE_Time_Value (4,0); // Now (monotonic time) + 3 sec
if (this->getq (b, &tv) != -1)
{
tv_now = tv.now ();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Second getq succeeded at %#T\n"), &tv_now));
delete b;
}
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Second getq timed out!\n")));
this->status_ = -1;
}
}
}
{
ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%P|%t) MyTask::svc - waiting for stop\n")));
if (!this->stop_)
this->cond_.wait ();
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%t) MyTask finished\n")));
return 0;
}
作者：dnjsflagh
项目：mmo_projec
int
run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT("Compiler_Features_13_Test"));
// As usual, the exit status from the test is 0 on success, 1 on
// failure
int status = 0;
{
// Make sure const cast works. Compilation is interesting, the
// functionality test here is just to make sure the compiler does
// not optimize things away ...
int x = 5;
int const & y = x;
const_cast<int&>(y) = 3;
if (x != 3)
{
status = 1;
ACE_ERROR((LM_ERROR,
ACE_TEXT("Wrong value after const_cast,")
ACE_TEXT(" expected %d, got %d\n"),
3, x));
}
}
// Make sure dynamic cast through pointers work ...
Derived d;
d.value = 24;
Base * b1 = &d;
Derived * d1 = dynamic_cast<Derived*>(b1);
if (d1 == 0)
{
status = 1;
ACE_ERROR((LM_ERROR,
ACE_TEXT("dynamic_cast returns null, expected value\n")));
}
d1->value = 42;
if (d.value != 42)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("Wrong value after dynamic_cast, expected %d, got %d\n"),
42, d.value));
}
// Make sure dynamic cast detects invalid casts
Another a;
Base * b2 = &a;
Derived * d2 = dynamic_cast<Derived*>(b2);
if (d2 != 0)
{
status = 1;
ACE_ERROR((LM_ERROR,
ACE_TEXT("dynamic_cast should return null\n")));
}
// Make sure dynamic cast raises an exception
Base & b3 = a;
try
{
(void) dynamic_cast<Derived&>(b3);
status = 1;
ACE_ERROR((LM_ERROR,
ACE_TEXT("dynamic_cast should have raised exception\n")));
}
catch(std::exception const &)
{
}
catch(...)
{
status = 1;
ACE_ERROR((LM_ERROR,
ACE_TEXT("dynamic_cast should have raised std::exception\n")));
}
{
// Just test these compile ...
double x = 42.0;
int y = static_cast<int>(x);
void * z = reinterpret_cast<void*>(y);
if (z == 0)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("My hack to make sure the code is not ")
ACE_TEXT("optimized away backfired!\n")));
}
}
ACE_END_TEST;
return status;
}
作者：asdlei0
项目：AC
int TestTask::svc()
{
try {
// Get reference to Root POA
CORBA::Object_var obj = orb_->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
// Activate POA Manager
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
// Find the Naming Service
obj = orb_->string_to_object ("corbaloc:iiop:[email protected]:9932/NameService");
CosNaming::NamingContext_var root =
CosNaming::NamingContext::_narrow(obj.in());
if (CORBA::is_nil(root.in())) {
ACE_ERROR ((LM_ERROR, "Error, Nil Naming Context reference\n"));
return 1;
}
// Bind the example Naming Context, if necessary
CosNaming::NamingContext_var example_nc;
CosNaming::Name name;
name.length(1);
name[0].id = CORBA::string_dup("example");
try
{
obj = root->resolve(name);
example_nc =
CosNaming::NamingContext::_narrow(obj.in());
}
catch (const CosNaming::NamingContext::NotFound&)
{
example_nc = root->bind_new_context(name);
}
// Bind the Test object
name.length(2);
name[1].id = CORBA::string_dup("Hello");
// Create an object
Hello servant(orb_.in ());
PortableServer::ObjectId_var oid = poa->activate_object(&servant);
obj = poa->id_to_reference(oid.in());
root->rebind(name, obj.in());
ACE_DEBUG ((LM_INFO, "Hello object bound in Naming Service B\n"));
name.length(1);
obj = orb_->string_to_object ("corbaloc:iiop:[email protected]:9931/NameService");
root = CosNaming::NamingContext::_narrow(obj.in());
root->bind_context (name, example_nc.in ());
ACE_DEBUG ((LM_INFO, "'example' context of NS B bound in Naming Service A\n"));
CORBA::String_var ior =
orb_->object_to_string (obj.in ());
// Output the IOR to the <ior_output_file>
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file %s for writing IOR: %C\n",
ior_output_file,
ior.in ()),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
ACE_DEBUG ((LM_INFO, "Wrote IOR file\n"));
// Normally we run the orb and the orb is shutdown by
// calling TestTask::end().
// Accept requests
orb_->run();
orb_->destroy();
return 0;
}
catch (CORBA::Exception& ex)
{
ex._tao_print_exception ("CORBA exception: ");
}
return -1;
}
作者：asdlei0
项目：AC
// Parse arguments on command line
void
DRV_parse_args (long ac, char **av)
{
ACE_CString buffer;
char *s = 0;
long i;
bool has_space = false;
FE_store_env_include_paths ();
DRV_cpp_init ();
idl_global->set_prog_name (av[0]);
for (i = 1; i < ac; i++)
{
if (av[i][0] == '-')
{
idl_global->append_idl_flag (av[i]);
switch (av[i][1])
{
case 0:
// One or more letters expected after the dash.
ACE_ERROR ((
LM_ERROR,
ACE_TEXT ("IDL: Space between dash and option ")
ACE_TEXT ("letters not allowed\n")
));
++i;
idl_global->set_err_count (idl_global->err_count () + 1);
break;
case 'A':
if (av[i][2] == '\0')
{
if (i < ac - 1)
{
s = av[i + 1];
++i;
}
else
{
ACE_ERROR ((
LM_ERROR,
ACE_TEXT ("IDL: incorrect use of ")
ACE_TEXT ("the -A option\n")
));
idl_global->set_compile_flags (
idl_global->compile_flags ()
| IDL_CF_ONLY_USAGE
);
break;
}
}
else
{
s = av[i] + 2;
}
ACE_OS::strcat (idl_global->local_escapes (), s);
ACE_OS::strcat (idl_global->local_escapes (), " ");
break;
case 'a':
if (av[i][2] == 'e')
{
idl_global->anon_type_diagnostic (
IDL_GlobalData::ANON_TYPE_ERROR);
}
else if (av[i][2] == 'w')
{
idl_global->anon_type_diagnostic (
IDL_GlobalData::ANON_TYPE_WARNING);
}
else if (av[i][2] == 's')
{
idl_global->anon_type_diagnostic (
IDL_GlobalData::ANON_TYPE_SILENT);
}
else
{
ACE_ERROR ((
LM_ERROR,
ACE_TEXT ("IDL: I don't understand")
ACE_TEXT (" the '%s' option\n"),
ACE_TEXT_CHAR_TO_TCHAR (av[i])
));
}
break;
// Temp directory for the IDL compiler to keep its files.
case 't':
if ((av[i][2] == '\0') && (i < ac - 1))
{
idl_global->append_idl_flag (av[i + 1]);
idl_global->temp_dir (av[i + 1]);
++i;
}
else
{
//.........这里部分代码省略.........
作者：chenbk8
项目：ACE-Middlewar
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int priority =
(ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
+ ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
// Enable FIFO scheduling, e.g., RT scheduling class on Solaris.
if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
priority,
ACE_SCOPE_PROCESS)) != 0)
{
if (ACE_OS::last_error () == EPERM)
{
ACE_DEBUG ((LM_DEBUG,
"client (%P|%t): user is not superuser, "
"test runs in time-shared class\n"));
}
else
ACE_ERROR ((LM_ERROR,
"client (%P|%t): sched_params failed\n"));
}
int interceptor_type;
get_interceptor_type (argc, argv, interceptor_type);
try
{
PortableInterceptor::ORBInitializer_ptr temp_initializer;
ACE_NEW_RETURN (temp_initializer,
Client_ORBInitializer (interceptor_type),
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (initializer.in ());
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
Test_Interceptors::Secure_Vault_var server =
Test_Interceptors::Secure_Vault::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
ACE_DEBUG ((LM_DEBUG, "\nFunctionality test begins now...\n"));
// This test is useful for benchmarking the differences when
// the same method is intercepted by different interceptors
// wanting to achieve different functionality.
run_test (server.in ());
server->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
作者：CCJ
项目：ATC
int asynch_foo_generator::svc ()
{
// multiple
::UsesSM::Sender::sendc_run_my_um_oneConnections_var my_one_ami_ =
context_->get_connections_sendc_run_my_um_one();
// simplex
::UsesSM::AMI4CCM_Two_var my_two_ami_ =
context_->get_connection_sendc_run_my_two();
if (my_one_ami_->length () == 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR Sender (ASYNCH) :my_one_ami_ is NIL !\n"));
return 1;
}
if (CORBA::is_nil (my_two_ami_))
{
ACE_ERROR ((LM_ERROR,
"ERROR Sender (ASYNCH) :my_two_ami_ is NIL !\n"));
return 1;
}
// Invoke Asynchronous calls to test
for (CORBA::ULong i = 0; i < my_one_ami_->length (); ++i)
{
::UsesSM::AMI4CCM_OneReplyHandler_var cb_one =
new AMI4CCM_OneReplyHandler_run_my_um_one_i (
this->nr_of_received_,
this->nr_of_sent_);
CORBA::String_var test;
switch (i)
{
case 0:
test = CORBA::string_dup ("Asynch. foo call one");
break;
case 1:
test = CORBA::string_dup ("Asynch. foo call two");
break;
case 2:
test = CORBA::string_dup ("Asynch. foo call three");
break;
default:
break;
}
++this->nr_of_sent_;
my_one_ami_[i].objref->sendc_foo (cb_one.in (),
test.in (),
i);
ACE_DEBUG ((LM_DEBUG, "Sender (ASYNCH) : send <%C> !\n",
test.in ()));
// There is more than 1 message sent, without receiving callbacks,
// so it is asynchronous
if (this->nr_of_sent_.value() > 1)
{
asynch = true;
}
ACE_DEBUG ((LM_DEBUG,
"Sender (ASYNCH) : send asynch call bar <%u>!\n", i));
::UsesSM::AMI4CCM_TwoReplyHandler_var cb_two =
new AMI4CCM_TwoReplyHandler_run_my_two_i (
this->nr_of_received_);
my_two_ami_->sendc_bar ( cb_two.in (), i);
}
return 0;
}
作者：stonejiang20
项目：OpenDD
void DataReaderListenerImpl::on_data_available(DDS::DataReader_ptr reader)
throw(CORBA::SystemException)
{
++num_reads_;
try {
Messenger::MessageDataReader_var message_dr =
Messenger::MessageDataReader::_narrow(reader);
if (CORBA::is_nil(message_dr.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("%N:%l: on_data_available()")
ACE_TEXT(" ERROR: _narrow failed!\n")));
ACE_OS::exit(-1);
}
Messenger::Message message;
DDS::SampleInfo si;
DDS::ReturnCode_t status = message_dr->take_next_sample(message, si) ;
if (status == DDS::RETCODE_OK) {
std::cout << "SampleInfo.sample_rank = " << si.sample_rank << std::endl;
std::cout << "SampleInfo.instance_state = " << si.instance_state << std::endl;
if (si.valid_data) {
if (!counts_.insert(message.count).second) {
std::cout << "ERROR: Repeat ";
valid_ = false;
}
phases_.insert(message.phase_number);
std::cout << "Message: subject = " << message.subject.in() << std::endl
<< " subject_id = " << message.subject_id << std::endl
<< " from = " << message.from.in() << std::endl
<< " count = " << message.count << std::endl
<< " phase = " << message.phase_number << std::endl
<< " text = " << message.text.in() << std::endl;
if (std::string("Comic Book Guy") != message.from.in() &&
std::string("OpenDDS-Java") != message.from.in()) {
std::cout << "ERROR: Invalid message.from" << std::endl;
valid_ = false;
}
if (std::string("Review") != message.subject.in()) {
std::cout << "ERROR: Invalid message.subject" << std::endl;
valid_ = false;
}
if (std::string("Worst. Movie. Ever.") != message.text.in()) {
std::cout << "ERROR: Invalid message.text" << std::endl;
valid_ = false;
}
if (message.subject_id != 99) {
std::cout << "ERROR: Invalid message.subject_id" << std::endl;
valid_ = false;
}
} else if (si.instance_state == DDS::NOT_ALIVE_DISPOSED_INSTANCE_STATE) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%N:%l: INFO: instance is disposed\n")));
} else if (si.instance_state == DDS::NOT_ALIVE_NO_WRITERS_INSTANCE_STATE) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%N:%l: INFO: instance is unregistered\n")));
} else {
ACE_ERROR((LM_ERROR,
ACE_TEXT("%N:%l: on_data_available()")
ACE_TEXT(" ERROR: unknown instance state: %d\n"),
si.instance_state));
valid_ = false;
}
} else {
ACE_ERROR((LM_ERROR,
ACE_TEXT("%N:%l: on_data_available()")
ACE_TEXT(" ERROR: unexpected status: %d\n"),
status));
valid_ = false;
}
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in on_data_available():");
ACE_OS::exit(-1);
}
}
作者：manu
项目：AC
//.........这里部分代码省略.........
H::write_array (os, idata, total);
crono.stop ();
secs = crono.read_seconds ();
}
else
{
int i = 0;
for (; i < dst_offset; i++)
{
os << T(0);
}
i = 0;
Crono crono;
crono.start();
while (i < total)
{
os << idata[i++];
os << idata[i++];
os << idata[i++];
os << idata[i++];
// static char rs[32 + 1];
// CDR_Test<T,H>::ttoh (idata[i], rs);
// ACE_DEBUG ((LM_DEBUG, "Write idata[%d] = %s\n", i, rs));
// os << idata[i];
// i++;
}
crono.stop ();
secs = crono.read_seconds ();
}
if (!check_seal(end))
{
ACE_ERROR((LM_ERROR,
ACE_TEXT( "Broken seal, aborting.\n" )));
ACE_OS::exit(1);
}
totalsecs += secs;
if (n == niter - 1)
{
toread = os.begin ()->rd_ptr ();
}
}
totalsecs = totalsecs / niter;
ACE_DEBUG((LM_DEBUG,
ACE_TEXT ("Writing to stream %d %s values: %f seconds.\n"),
total,
H::name (),
totalsecs));
}
{
int i;
for (i = 0; i < total; i++)
{
idata[i] = 0;
}
}
ACE_DEBUG((LM_DEBUG,
ACE_TEXT( "Reading them back in opposing byte order...\n" )));
