void filter_object::test<1>() { set_test_name("LLEventMatching"); LLEventPump& driver(pumps.obtain("driver")); listener0.reset(0); // Listener isn't derived from LLEventTrackable specifically to test // various connection-management mechanisms. But that means we have a // couple of transient Listener objects, one of which is listening to // a persistent LLEventPump. Capture those connections in local // LLTempBoundListener instances so they'll disconnect // on destruction. LLTempBoundListener temp1( listener0.listenTo(driver)); // Construct a pattern LLSD: desired Event must have a key "foo" // containing string "bar" LLEventMatching filter(driver, LLSD().insert("foo", "bar")); listener1.reset(0); LLTempBoundListener temp2( listener1.listenTo(filter)); driver.post(1); check_listener("direct", listener0, LLSD(1)); check_listener("filtered", listener1, LLSD(0)); // Okay, construct an LLSD map matching the pattern LLSD data; data["foo"] = "bar"; data["random"] = 17; driver.post(data); check_listener("direct", listener0, data); check_listener("filtered", listener1, data); }
void filter_object::test<3>() { set_test_name("LLEventTimeout::eventAfter()"); LLEventPump& driver(pumps.obtain("driver")); TestEventTimeout filter(driver); listener0.reset(0); LLTempBoundListener temp1( listener0.listenTo(filter)); filter.eventAfter(20, LLSD("timeout")); // Okay, (fake) timer is ticking. 'filter' can only sense the timer // when we pump mainloop. Do that right now to take the logic path // before either the anticipated event arrives or the timer expires. mainloop.post(17); check_listener("no timeout 1", listener0, LLSD(0)); // Expected event arrives... driver.post(1); check_listener("event passed thru", listener0, LLSD(1)); // Should have canceled the timer. Verify that by asserting that the // time has expired, then pumping mainloop again. filter.forceTimeout(); mainloop.post(17); check_listener("no timeout 2", listener0, LLSD(1)); // Set timer again. filter.eventAfter(20, LLSD("timeout")); // Now let the timer expire. filter.forceTimeout(); // Notice the timeout. mainloop.post(17); check_listener("timeout", listener0, LLSD("timeout")); // Timing out cancels the timer. Verify that. listener0.reset(0); filter.forceTimeout(); mainloop.post(17); check_listener("no timeout 3", listener0, LLSD(0)); }
/** * g_socket_listener_accept_socket_async: * @listener: a #GSocketListener * @cancellable: (allow-none): a #GCancellable, or %NULL * @callback: (scope async): a #GAsyncReadyCallback * @user_data: (closure): user data for the callback * * This is the asynchronous version of g_socket_listener_accept_socket(). * * When the operation is finished @callback will be * called. You can then call g_socket_listener_accept_socket_finish() * to get the result of the operation. * * Since: 2.22 */ void g_socket_listener_accept_socket_async (GSocketListener *listener, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; GList *sources; GError *error = NULL; task = g_task_new (listener, cancellable, callback, user_data); if (!check_listener (listener, &error)) { g_task_return_error (task, error); g_object_unref (task); return; } sources = add_sources (listener, accept_ready, task, cancellable, g_main_context_get_thread_default ()); g_task_set_task_data (task, sources, (GDestroyNotify) free_sources); }
/** * g_socket_listener_add_socket: * @listener: a #GSocketListener * @socket: a listening #GSocket * @source_object: (allow-none): Optional #GObject identifying this source * @error: #GError for error reporting, or %NULL to ignore. * * Adds @socket to the set of sockets that we try to accept * new clients from. The socket must be bound to a local * address and listened to. * * @source_object will be passed out in the various calls * to accept to identify this particular source, which is * useful if you're listening on multiple addresses and do * different things depending on what address is connected to. * * Returns: %TRUE on success, %FALSE on error. * * Since: 2.22 */ gboolean g_socket_listener_add_socket (GSocketListener *listener, GSocket *socket, GObject *source_object, GError **error) { if (!check_listener (listener, error)) return FALSE; /* TODO: Check that socket it is bound & not closed? */ if (g_socket_is_closed (socket)) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Added socket is closed")); return FALSE; } g_object_ref (socket); g_ptr_array_add (listener->priv->sockets, socket); if (source_object) g_object_set_qdata_full (G_OBJECT (socket), source_quark, g_object_ref (source_object), g_object_unref); if (G_SOCKET_LISTENER_GET_CLASS (listener)->changed) G_SOCKET_LISTENER_GET_CLASS (listener)->changed (listener); return TRUE; }
/** * g_socket_listener_add_address: * @listener: a #GSocketListener * @address: a #GSocketAddress * @type: a #GSocketType * @protocol: a #GSocketProtocol * @source_object: (allow-none): Optional #GObject identifying this source * @effective_address: (out) (allow-none): location to store the address that was bound to, or %NULL. * @error: #GError for error reporting, or %NULL to ignore. * * Creates a socket of type @type and protocol @protocol, binds * it to @address and adds it to the set of sockets we're accepting * sockets from. * * Note that adding an IPv6 address, depending on the platform, * may or may not result in a listener that also accepts IPv4 * connections. For more deterministic behavior, see * g_socket_listener_add_inet_port(). * * @source_object will be passed out in the various calls * to accept to identify this particular source, which is * useful if you're listening on multiple addresses and do * different things depending on what address is connected to. * * If successful and @effective_address is non-%NULL then it will * be set to the address that the binding actually occurred at. This * is helpful for determining the port number that was used for when * requesting a binding to port 0 (ie: "any port"). This address, if * requested, belongs to the caller and must be freed. * * Returns: %TRUE on success, %FALSE on error. * * Since: 2.22 */ gboolean g_socket_listener_add_address (GSocketListener *listener, GSocketAddress *address, GSocketType type, GSocketProtocol protocol, GObject *source_object, GSocketAddress **effective_address, GError **error) { GSocketAddress *local_address; GSocketFamily family; GSocket *socket; if (!check_listener (listener, error)) return FALSE; family = g_socket_address_get_family (address); socket = g_socket_new (family, type, protocol, error); if (socket == NULL) return FALSE; g_socket_set_listen_backlog (socket, listener->priv->listen_backlog); if (!g_socket_bind (socket, address, TRUE, error) || !g_socket_listen (socket, error)) { g_object_unref (socket); return FALSE; } local_address = NULL; if (effective_address) { local_address = g_socket_get_local_address (socket, error); if (local_address == NULL) { g_object_unref (socket); return FALSE; } } if (!g_socket_listener_add_socket (listener, socket, source_object, error)) { if (local_address) g_object_unref (local_address); g_object_unref (socket); return FALSE; } if (effective_address) *effective_address = local_address; g_object_unref (socket); /* add_socket refs this */ return TRUE; }
void filter_object::test<4>() { set_test_name("LLEventTimeout::errorAfter()"); WrapLLErrs capture; LLEventPump& driver(pumps.obtain("driver")); TestEventTimeout filter(driver); listener0.reset(0); LLTempBoundListener temp1( listener0.listenTo(filter)); filter.errorAfter(20, "timeout"); // Okay, (fake) timer is ticking. 'filter' can only sense the timer // when we pump mainloop. Do that right now to take the logic path // before either the anticipated event arrives or the timer expires. mainloop.post(17); check_listener("no timeout 1", listener0, LLSD(0)); // Expected event arrives... driver.post(1); check_listener("event passed thru", listener0, LLSD(1)); // Should have canceled the timer. Verify that by asserting that the // time has expired, then pumping mainloop again. filter.forceTimeout(); mainloop.post(17); check_listener("no timeout 2", listener0, LLSD(1)); // Set timer again. filter.errorAfter(20, "timeout"); // Now let the timer expire. filter.forceTimeout(); // Notice the timeout. std::string threw; try { mainloop.post(17); } catch (const WrapLLErrs::FatalException& e) { threw = e.what(); } ensure_contains("errorAfter() timeout exception", threw, "timeout"); // Timing out cancels the timer. Verify that. listener0.reset(0); filter.forceTimeout(); mainloop.post(17); check_listener("no timeout 3", listener0, LLSD(0)); }
/** * g_socket_listener_accept_socket: * @listener: a #GSocketListener * @source_object: (out) (transfer none) (allow-none): location where #GObject pointer will be stored, or %NULL. * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore. * @error: #GError for error reporting, or %NULL to ignore. * * Blocks waiting for a client to connect to any of the sockets added * to the listener. Returns the #GSocket that was accepted. * * If you want to accept the high-level #GSocketConnection, not a #GSocket, * which is often the case, then you should use g_socket_listener_accept() * instead. * * If @source_object is not %NULL it will be filled out with the source * object specified when the corresponding socket or address was added * to the listener. * * If @cancellable is not %NULL, then the operation can be cancelled by * triggering the cancellable object from another thread. If the operation * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. * * Returns: (transfer full): a #GSocket on success, %NULL on error. * * Since: 2.22 */ GSocket * g_socket_listener_accept_socket (GSocketListener *listener, GObject **source_object, GCancellable *cancellable, GError **error) { GSocket *accept_socket, *socket; g_return_val_if_fail (G_IS_SOCKET_LISTENER (listener), NULL); if (!check_listener (listener, error)) return NULL; if (listener->priv->sockets->len == 1) { accept_socket = listener->priv->sockets->pdata[0]; if (!g_socket_condition_wait (accept_socket, G_IO_IN, cancellable, error)) return NULL; } else { GList *sources; struct AcceptData data; GMainLoop *loop; if (listener->priv->main_context == NULL) listener->priv->main_context = g_main_context_new (); loop = g_main_loop_new (listener->priv->main_context, FALSE); data.loop = loop; sources = add_sources (listener, accept_callback, &data, cancellable, listener->priv->main_context); g_main_loop_run (loop); accept_socket = data.socket; free_sources (sources); g_main_loop_unref (loop); } if (!(socket = g_socket_accept (accept_socket, cancellable, error))) return NULL; if (source_object) *source_object = g_object_get_qdata (G_OBJECT (accept_socket), source_quark); return socket; }
void filter_object::test<2>() { set_test_name("LLEventTimeout::actionAfter()"); LLEventPump& driver(pumps.obtain("driver")); TestEventTimeout filter(driver); listener0.reset(0); LLTempBoundListener temp1( listener0.listenTo(filter)); // Use listener1.call() as the Action for actionAfter(), since it // already provides a way to sense the call listener1.reset(0); // driver --> filter --> listener0 filter.actionAfter(20, boost::bind(&Listener::call, boost::ref(listener1), LLSD("timeout"))); // Okay, (fake) timer is ticking. 'filter' can only sense the timer // when we pump mainloop. Do that right now to take the logic path // before either the anticipated event arrives or the timer expires. mainloop.post(17); check_listener("no timeout 1", listener1, LLSD(0)); // Expected event arrives... driver.post(1); check_listener("event passed thru", listener0, LLSD(1)); // Should have canceled the timer. Verify that by asserting that the // time has expired, then pumping mainloop again. filter.forceTimeout(); mainloop.post(17); check_listener("no timeout 2", listener1, LLSD(0)); // Verify chained actionAfter() calls, that is, that a second // actionAfter() resets the timer established by the first // actionAfter(). filter.actionAfter(20, boost::bind(&Listener::call, boost::ref(listener1), LLSD("timeout"))); // Since our TestEventTimeout class isn't actually manipulating time // (quantities of seconds), only a bool "elapsed" flag, sense that by // forcing the flag between actionAfter() calls. filter.forceTimeout(); // Pumping mainloop here would result in a timeout (as we'll verify // below). This state simulates a ticking timer that has not yet timed // out. But now, before a mainloop event lets 'filter' recognize // timeout on the previous actionAfter() call, pretend we're pushing // that timeout farther into the future. filter.actionAfter(20, boost::bind(&Listener::call, boost::ref(listener1), LLSD("timeout"))); // Look ma, no timeout! mainloop.post(17); check_listener("no timeout 3", listener1, LLSD(0)); // Now let the updated actionAfter() timer expire. filter.forceTimeout(); // Notice the timeout. mainloop.post(17); check_listener("timeout", listener1, LLSD("timeout")); // Timing out cancels the timer. Verify that. listener1.reset(0); filter.forceTimeout(); mainloop.post(17); check_listener("no timeout 4", listener1, LLSD(0)); // Reset the timer and then cancel() it. filter.actionAfter(20, boost::bind(&Listener::call, boost::ref(listener1), LLSD("timeout"))); // neither expired nor satisified mainloop.post(17); check_listener("no timeout 5", listener1, LLSD(0)); // cancel filter.cancel(); // timeout! filter.forceTimeout(); mainloop.post(17); check_listener("no timeout 6", listener1, LLSD(0)); }
/** * g_socket_listener_add_inet_port: * @listener: a #GSocketListener * @port: an IP port number (non-zero) * @source_object: (allow-none): Optional #GObject identifying this source * @error: #GError for error reporting, or %NULL to ignore. * * Helper function for g_socket_listener_add_address() that * creates a TCP/IP socket listening on IPv4 and IPv6 (if * supported) on the specified port on all interfaces. * * @source_object will be passed out in the various calls * to accept to identify this particular source, which is * useful if you're listening on multiple addresses and do * different things depending on what address is connected to. * * Returns: %TRUE on success, %FALSE on error. * * Since: 2.22 */ gboolean g_socket_listener_add_inet_port (GSocketListener *listener, guint16 port, GObject *source_object, GError **error) { gboolean need_ipv4_socket = TRUE; GSocket *socket4 = NULL; GSocket *socket6; g_return_val_if_fail (listener != NULL, FALSE); g_return_val_if_fail (port != 0, FALSE); if (!check_listener (listener, error)) return FALSE; /* first try to create an IPv6 socket */ socket6 = g_socket_new (G_SOCKET_FAMILY_IPV6, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL); if (socket6 != NULL) /* IPv6 is supported on this platform, so if we fail now it is * a result of being unable to bind to our port. Don't fail * silently as a result of this! */ { GInetAddress *inet_address; GSocketAddress *address; gboolean result; inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV6); address = g_inet_socket_address_new (inet_address, port); g_object_unref (inet_address); g_socket_set_listen_backlog (socket6, listener->priv->listen_backlog); result = g_socket_bind (socket6, address, TRUE, error) && g_socket_listen (socket6, error); g_object_unref (address); if (!result) { g_object_unref (socket6); return FALSE; } if (source_object) g_object_set_qdata_full (G_OBJECT (socket6), source_quark, g_object_ref (source_object), g_object_unref); /* If this socket already speaks IPv4 then we are done. */ if (g_socket_speaks_ipv4 (socket6)) need_ipv4_socket = FALSE; } if (need_ipv4_socket) /* We are here for exactly one of the following reasons: * * - our platform doesn't support IPv6 * - we successfully created an IPv6 socket but it's V6ONLY * * In either case, we need to go ahead and create an IPv4 socket * and fail the call if we can't bind to it. */ { socket4 = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, error); if (socket4 != NULL) /* IPv4 is supported on this platform, so if we fail now it is * a result of being unable to bind to our port. Don't fail * silently as a result of this! */ { GInetAddress *inet_address; GSocketAddress *address; gboolean result; inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4); address = g_inet_socket_address_new (inet_address, port); g_object_unref (inet_address); g_socket_set_listen_backlog (socket4, listener->priv->listen_backlog); result = g_socket_bind (socket4, address, TRUE, error) && g_socket_listen (socket4, error); g_object_unref (address); if (!result) { g_object_unref (socket4); if (socket6 != NULL) g_object_unref (socket6); return FALSE; } if (source_object) g_object_set_qdata_full (G_OBJECT (socket4), source_quark, g_object_ref (source_object), g_object_unref); } else /* Ok. So IPv4 is not supported on this platform. If we * succeeded at creating an IPv6 socket then that's OK, but * otherwise we need to tell the user we failed. */ { if (socket6 != NULL) g_clear_error (error); else return FALSE; } } g_assert (socket6 != NULL || socket4 != NULL); if (socket6 != NULL) g_ptr_array_add (listener->priv->sockets, socket6); if (socket4 != NULL) g_ptr_array_add (listener->priv->sockets, socket4); if (G_SOCKET_LISTENER_GET_CLASS (listener)->changed) G_SOCKET_LISTENER_GET_CLASS (listener)->changed (listener); return TRUE; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int status = 0; try { ACE_DEBUG((LM_INFO,"(%P|%t) %T subscriber main\n")); ::DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv); // TheServiceParticipant->liveliness_factor(100); // let the Service_Participant (in above line) strip out -DCPSxxx parameters // and then get application specific parameters. parse_args(argc, argv); if (!topics) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) Must run with one or more of the following: -s1 -s2 -s3 -s4 -s5 -p6 -p7\n"))); return 1; } ::T1::Foo1TypeSupport_var fts1; ::T4::Foo4TypeSupport_var fts4; if (topics & (TOPIC_T1 | TOPIC_T3 | TOPIC_T4| TOPIC_T5)) { fts1 = new ::T1::Foo1TypeSupportImpl; } if (topics & TOPIC_T2) { fts4 = new ::T4::Foo4TypeSupportImpl; } ::DDS::DomainParticipant_var dp = dpf->create_participant(MY_DOMAIN, PARTICIPANT_QOS_DEFAULT, ::DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(dp)) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) create_participant failed.\n"))); return 1; } if (topics & (TOPIC_T1 | TOPIC_T3 | TOPIC_T4 | TOPIC_T5)) { if (::DDS::RETCODE_OK != fts1->register_type(dp, MY_TYPE1)) { ACE_ERROR((LM_ERROR, ACE_TEXT("Failed to register the Foo1TypeSupport."))); return 1; } } if (topics & TOPIC_T2) { if (::DDS::RETCODE_OK != fts4->register_type(dp, MY_TYPE4)) { ACE_ERROR((LM_ERROR, ACE_TEXT("Failed to register the Foo4TypeSupport."))); return 1; } } ::DDS::Topic_var topic1; ::DDS::Topic_var topic2; ::DDS::Topic_var topic3; ::DDS::Topic_var topic4; ::DDS::Topic_var topic5; ::DDS::Topic_var topic6; ::DDS::Topic_var topic7; if (topics & TOPIC_T1) { topic1 = dp->create_topic(MY_TOPIC1, MY_TYPE1, TOPIC_QOS_DEFAULT, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(topic1)) { return 1; } } if (topics & TOPIC_T2) { topic2 = dp->create_topic(MY_TOPIC2, MY_TYPE4, TOPIC_QOS_DEFAULT, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(topic2)) { return 1; } } if (topics & TOPIC_T3) { topic3 = dp->create_topic(MY_TOPIC3, MY_TYPE1, TOPIC_QOS_DEFAULT, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(topic3)) { return 1; } } if (topics & TOPIC_T4) { topic4 = dp->create_topic(MY_TOPIC4, MY_TYPE1, TOPIC_QOS_DEFAULT, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(topic4)) { return 1; } } if (topics & TOPIC_T5) { topic5 = dp->create_topic(MY_TOPIC5, MY_TYPE1, TOPIC_QOS_DEFAULT, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(topic5)) { return 1; } } if (publish_topics & TOPIC_T6) { topic6 = dp->create_topic(MY_TOPIC6, MY_TYPE1, TOPIC_QOS_DEFAULT, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(topic6)) { return 1; } } if (publish_topics & TOPIC_T7) { topic7 = dp->create_topic(MY_TOPIC7, MY_TYPE1, TOPIC_QOS_DEFAULT, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(topic7)) { return 1; } } //////////////////////////////////////////////////////////////////////////// // Create the publisher and datawriter //////////////////////////////////////////////////////////////////////////// ::DDS::Publisher_var pub = dp->create_publisher(PUBLISHER_QOS_DEFAULT, ::DDS::PublisherListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(pub)) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) create_publisher failed.\n")), 1); } ::DDS::DataWriterQos dw_qos; pub->get_default_datawriter_qos(dw_qos); dw_qos.resource_limits.max_samples_per_instance = max_samples_per_instance; dw_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC; dw_qos.liveliness.lease_duration.nanosec = 0; int num_writers(0); ::DDS::DataWriter_var dw1; ::DDS::DataWriter_var dw2; if (publish_topics & TOPIC_T6) { dw1 = pub->create_datawriter(topic6, dw_qos, ::DDS::DataWriterListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(dw1)) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) create_datawriter failed.\n"))); return 1; } ++num_writers; } if (publish_topics & TOPIC_T7) { dw2 = pub->create_datawriter(topic7, dw_qos, ::DDS::DataWriterListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(dw2)) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) create_datawriter failed.\n"))); return 1; } ++num_writers; } Writer** writers = new Writer*[num_writers]; int idx(0); if (publish_topics & TOPIC_T6) { writers[idx++] = new Writer(dw1, 1, num_ops_per_thread); } if (publish_topics & TOPIC_T7) { writers[idx++] = new Writer(dw2, 1, num_ops_per_thread); } for (int i = 0; i < num_writers; ++i) { writers[i]->start(); } //////////////////////////////////////////////////////////////////////////// // Create the subscriber //////////////////////////////////////////////////////////////////////////// ::DDS::Subscriber_var sub = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT, ::DDS::SubscriberListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(sub)) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%P|%t) create_subscriber failed.\n")), 1); } // Create the Datareaders ::DDS::DataReaderQos dr_qos; sub->get_default_datareader_qos(dr_qos); dr_qos.resource_limits.max_samples_per_instance = max_samples_per_instance; dr_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC; dr_qos.liveliness.lease_duration.nanosec = 0; dr_qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS; ::DDS::DataReader_var dr1; ::DDS::DataReader_var dr2_1; ::DDS::DataReader_var dr2_2; ::DDS::DataReader_var dr2_3; ::DDS::DataReader_var dr3; ::DDS::DataReader_var dr4; ::DDS::DataReader_var dr5; ::DDS::DataReaderListener_var drl1 = new DataReaderListenerImpl1(num_ops_per_thread); ::DDS::DataReaderListener_var drl2_1 = new DataReaderListenerImpl4(num_ops_per_thread); ::DDS::DataReaderListener_var drl2_2 = new DataReaderListenerImpl4(num_ops_per_thread); ::DDS::DataReaderListener_var drl2_3 = new DataReaderListenerImpl4(num_ops_per_thread); ::DDS::DataReaderListener_var drl3 = new DataReaderListenerImpl1(num_ops_per_thread); ::DDS::DataReaderListener_var drl4 = new DataReaderListenerImpl1(num_ops_per_thread); ::DDS::DataReaderListener_var drl5 = new DataReaderListenerImpl1(num_ops_per_thread); if (topics & TOPIC_T1) { dr1 = sub->create_datareader(topic1, dr_qos, drl1, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); } if (topics & TOPIC_T2) { dr2_1 = sub->create_datareader(topic2, dr_qos, drl2_1, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); dr2_2 = sub->create_datareader(topic2, dr_qos, drl2_2, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); dr2_3 = sub->create_datareader(topic2, dr_qos, drl2_3, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); } if (topics & TOPIC_T3) { dr3 = sub->create_datareader(topic3, dr_qos, drl3, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); } if (topics & TOPIC_T4) { dr4 = sub->create_datareader(topic4, dr_qos, drl4, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); } if (topics & TOPIC_T5) { dr5 = sub->create_datareader(topic5, dr_qos, drl5, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); } if (topics & TOPIC_T1) { const DataReaderListenerImpl* const drl_servant = dynamic_cast<const DataReaderListenerImpl*>(drl1.in()); if (!check_listener(drl_servant, num_ops_per_thread, ACE_TEXT(MY_TOPIC1))) status = 1; } if (topics & TOPIC_T2) { const DataReaderListenerImpl* const drl2_1srv = dynamic_cast<const DataReaderListenerImpl*>(drl2_1.in()); if (!check_listener(drl2_1srv, num_ops_per_thread, ACE_TEXT(MY_TOPIC2))) status = 1; const DataReaderListenerImpl* const drl2_2srv = dynamic_cast<const DataReaderListenerImpl*>(drl2_2.in()); if (!check_listener(drl2_2srv, num_ops_per_thread, ACE_TEXT(MY_TOPIC2))) status = 1; const DataReaderListenerImpl* const drl2_3srv = dynamic_cast<const DataReaderListenerImpl*>(drl2_3.in()); if (!check_listener(drl2_3srv, num_ops_per_thread, ACE_TEXT(MY_TOPIC2))) status = 1; } if (topics & TOPIC_T3) { const DataReaderListenerImpl* const drl_servant = dynamic_cast<const DataReaderListenerImpl*>(drl3.in()); if (!check_listener(drl_servant, num_ops_per_thread, ACE_TEXT(MY_TOPIC3))) status = 1; } if (topics & TOPIC_T4) { const DataReaderListenerImpl* const drl_servant = dynamic_cast<const DataReaderListenerImpl*>(drl4.in()); if (!check_listener(drl_servant, num_ops_per_thread, ACE_TEXT(MY_TOPIC4))) status = 1; } if (topics & TOPIC_T5) { const DataReaderListenerImpl* const drl_servant = dynamic_cast<const DataReaderListenerImpl*>(drl5.in()); if (!check_listener(drl_servant, num_ops_per_thread, ACE_TEXT(MY_TOPIC5))) status = 1; } if (topics & TOPIC_T1) { wait_for_file(ACE_TEXT(MY_TOPIC1), pub_finished_filename); } if (topics & TOPIC_T2) { wait_for_file(ACE_TEXT(MY_TOPIC2), pub_finished_filename); } if (topics & TOPIC_T3) { wait_for_file(ACE_TEXT(MY_TOPIC3), pub_finished_filename); } if (topics & TOPIC_T4) { wait_for_file(ACE_TEXT(MY_TOPIC4), pub_finished_filename); } if (topics & TOPIC_T5) { wait_for_file(ACE_TEXT(MY_TOPIC5), pub_finished_filename); } if (publish_topics) { bool writers_finished = false; while (!writers_finished && num_writers) { writers_finished = true; for (int m = 0; m < num_writers; m++) { writers_finished = writers_finished && writers[m]->is_finished(); } if (!writers_finished) ACE_OS::sleep(small_time); } } if (publish_topics & TOPIC_T6) { ACE_TString t6_filename = ACE_TEXT(MY_TOPIC6) + pub_finished_filename; FILE* writers_completed = ACE_OS::fopen(t6_filename.c_str(), ACE_TEXT("w")); if (writers_completed == 0) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Unable to create publisher ") ACE_TEXT("completed file\n"))); status = 1; } else { ACE_OS::fclose(writers_completed); } } if (publish_topics & TOPIC_T7) { ACE_TString t7_filename = ACE_TEXT(MY_TOPIC7) + pub_finished_filename; FILE* writers_completed = ACE_OS::fopen(t7_filename.c_str(), ACE_TEXT("w")); if (writers_completed == 0) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Unable to create publisher ") ACE_TEXT("completed file\n"))); status = 1; } else { ACE_OS::fclose(writers_completed); } } ACE_DEBUG((LM_DEBUG, "(%P|%t) delete contained entities on pub\n")); pub->delete_contained_entities(); for (int n = 0; n < num_writers; ++n) { delete writers[n]; } delete [] writers; dp->delete_contained_entities(); dpf->delete_participant(dp); TheServiceParticipant->shutdown(); } catch (const TestException&) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) TestException caught in main.cpp.\n"))); return 1; } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught in main.cpp:"); return 1; } return status; }