/* * Timeout tests */ void SelectServerTest::testTimeout() { // Check a single timeout m_ss->RegisterSingleTimeout( 10, ola::NewSingleCallback(this, &SelectServerTest::SingleIncrementTimeout)); m_ss->RegisterSingleTimeout( 20, ola::NewSingleCallback(this, &SelectServerTest::Terminate)); m_ss->Run(); OLA_ASSERT_EQ(1u, m_timeout_counter); // Now check a timeout that adds another timeout m_timeout_counter = 0; m_ss->RegisterSingleTimeout( 10, ola::NewSingleCallback(this, &SelectServerTest::ReentrantTimeout, m_ss)); m_ss->RegisterSingleTimeout( 20, ola::NewSingleCallback(this, &SelectServerTest::Terminate)); m_ss->Run(); OLA_ASSERT_EQ(2u, m_timeout_counter); // Check repeating timeouts // Some systems (VMs in particular) can't do 10ms resolution so we go for // larger numbers here. m_timeout_counter = 0; m_ss->RegisterRepeatingTimeout( 100, ola::NewCallback(this, &SelectServerTest::IncrementTimeout)); m_ss->RegisterSingleTimeout( 980, ola::NewSingleCallback(this, &SelectServerTest::Terminate)); m_ss->Run(); // This seems to go as low as 7 std::ostringstream str; str << "Timeout counter was " << m_timeout_counter; OLA_ASSERT_TRUE_MSG(m_timeout_counter >= 5 && m_timeout_counter <= 9, str.str()); // Confirm timeouts are removed correctly ola::thread::timeout_id timeout1 = m_ss->RegisterSingleTimeout( 10, ola::NewSingleCallback(this, &SelectServerTest::FatalTimeout)); m_ss->RegisterSingleTimeout( 20, ola::NewSingleCallback(this, &SelectServerTest::Terminate)); m_ss->RemoveTimeout(timeout1); m_ss->Run(); }
/* * Check that RemoveWriteDescriptor is reentrant. * Similar to the case above, but this removes & deletes the descriptor from * within the OnRead callback of the same descriptor. */ void SelectServerTest::testRemoveWriteWhenReadable() { // Ownership is transferred to the SelectServer. LoopbackDescriptor *loopback = new LoopbackDescriptor(); loopback->Init(); loopback->SetOnData(NewCallback( this, &SelectServerTest::ReadDataAndRemove, static_cast<ConnectedDescriptor*>(loopback))); loopback->SetOnWritable(NewCallback(this, &SelectServerTest::NullHandler)); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(loopback)); OLA_ASSERT_TRUE(m_ss->AddWriteDescriptor(loopback)); OLA_ASSERT_EQ(2, connected_read_descriptor_count->Get()); OLA_ASSERT_EQ(1, write_descriptor_count->Get()); OLA_ASSERT_EQ(0, read_descriptor_count->Get()); // Send some data to make this descriptor readable. uint8_t data[] = {'a'}; loopback->Send(data, arraysize(data)); m_ss->Run(); OLA_ASSERT_EQ(0, write_descriptor_count->Get()); OLA_ASSERT_EQ(1, connected_read_descriptor_count->Get()); OLA_ASSERT_EQ(0, read_descriptor_count->Get()); }
/* * Main. */ int main(int argc, char **argv) { ola::AppInit(&argc, argv, "[ options ]", "Ja Rule Admin Tool"); auto_ptr<UID> controller_uid(UID::FromString(FLAGS_controller_uid)); if (!controller_uid.get()) { OLA_WARN << "Invalid Controller UID: '" << FLAGS_controller_uid << "'"; exit(ola::EXIT_USAGE); } if (controller_uid->IsBroadcast()) { OLA_WARN << "The controller UID should not be a broadcast UID"; exit(ola::EXIT_USAGE); } SelectServer ss; WidgetManager widget_manager(*controller_uid); InputHandler input_handler(&ss, *controller_uid, &widget_manager); USBDeviceManager manager( &ss, NewCallback(&widget_manager, &WidgetManager::WidgetEvent)); if (!manager.Start()) { exit(ola::EXIT_UNAVAILABLE); } ss.Run(); return ola::EXIT_OK; }
/** * Generic method to test server initiated close */ void SocketTest::SocketServerClose(ConnectedDescriptor *socket, ConnectedDescriptor *socket2) { OLA_ASSERT_NOT_NULL(socket); socket->SetOnData(ola::NewCallback( this, &SocketTest::Receive, static_cast<ConnectedDescriptor*>(socket))); socket->SetOnClose( ola::NewSingleCallback(this, &SocketTest::TerminateOnClose)); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(socket)); OLA_ASSERT_TRUE(socket2); socket2->SetOnData(ola::NewCallback( this, &SocketTest::ReceiveSendAndClose, static_cast<ConnectedDescriptor*>(socket2))); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(socket2)); ssize_t bytes_sent = socket->Send( static_cast<const uint8_t*>(test_cstring), sizeof(test_cstring)); OLA_ASSERT_EQ(static_cast<ssize_t>(sizeof(test_cstring)), bytes_sent); m_ss->Run(); m_ss->RemoveReadDescriptor(socket); m_ss->RemoveReadDescriptor(socket2); delete socket2; }
/* * Test UDP sockets with an IOQueue work correctly. * The client connects and the server sends some data. The client checks the * data matches and then closes the connection. */ void SocketTest::testIOQueueUDPSend() { IPV4SocketAddress socket_address(IPV4Address::Loopback(), 9010); UDPSocket socket; OLA_ASSERT_TRUE(socket.Init()); OLA_ASSERT_FALSE(socket.Init()); OLA_ASSERT_TRUE(socket.Bind(socket_address)); OLA_ASSERT_FALSE(socket.Bind(socket_address)); socket.SetOnData( ola::NewCallback(this, &SocketTest::UDPReceiveAndSend, &socket)); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(&socket)); UDPSocket client_socket; OLA_ASSERT_TRUE(client_socket.Init()); OLA_ASSERT_FALSE(client_socket.Init()); client_socket.SetOnData( ola::NewCallback( this, &SocketTest::UDPReceiveAndTerminate, static_cast<UDPSocket*>(&client_socket))); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(&client_socket)); IOQueue output; output.Write(static_cast<const uint8_t*>(test_cstring), sizeof(test_cstring)); ssize_t bytes_sent = client_socket.SendTo(&output, socket_address); OLA_ASSERT_EQ(static_cast<ssize_t>(sizeof(test_cstring)), bytes_sent); m_ss->Run(); m_ss->RemoveReadDescriptor(&socket); m_ss->RemoveReadDescriptor(&client_socket); }
/** * Check pausing doesn't mark the channel as bad. */ void HealthCheckedConnectionTest::testPauseAndResume() { MockHealthCheckedConnection connection(&socket, &m_ss, heartbeat_interval, options, &m_clock); socket.SetOnData( NewCallback(&connection, &MockHealthCheckedConnection::ReadData)); connection.Setup(); m_ss.AddReadDescriptor(&socket); connection.Setup(); m_ss.RegisterSingleTimeout( TimeInterval(1, 0), NewSingleCallback(this, &HealthCheckedConnectionTest::PauseReading, &connection)); m_ss.RegisterSingleTimeout( TimeInterval(3, 0), NewSingleCallback(this, &HealthCheckedConnectionTest::ResumeReading, &connection)); m_ss.Run(); OLA_ASSERT_TRUE(connection.ChannelOk()); }
/* * Test TCP sockets work correctly. * The client connects and the server then sends some data and closes the * connection. */ void SocketTest::testTCPSocketServerClose() { IPV4SocketAddress socket_address(IPV4Address::Loopback(), 0); ola::network::TCPSocketFactory socket_factory( ola::NewCallback(this, &SocketTest::NewConnectionSendAndClose)); TCPAcceptingSocket socket(&socket_factory); OLA_ASSERT_TRUE_MSG(socket.Listen(socket_address), "Check for another instance of olad running"); OLA_ASSERT_FALSE(socket.Listen(socket_address)); GenericSocketAddress local_address = socket.GetLocalAddress(); OLA_ASSERT_EQ(static_cast<uint16_t>(AF_INET), local_address.Family()); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(&socket)); // The client socket checks the response and terminates on close TCPSocket *client_socket = TCPSocket::Connect(local_address); OLA_ASSERT_NOT_NULL(client_socket); client_socket->SetOnData(ola::NewCallback( this, &SocketTest::Receive, static_cast<ConnectedDescriptor*>(client_socket))); client_socket->SetOnClose( ola::NewSingleCallback(this, &SocketTest::TerminateOnClose)); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(client_socket)); m_ss->Run(); m_ss->RemoveReadDescriptor(&socket); m_ss->RemoveReadDescriptor(client_socket); delete client_socket; }
/* * Check that we don't invalid iterators by removing descriptors during an * on_Write callback. */ void SelectServerTest::testRemoveOthersWhenWriteable() { Descriptors read_set, write_set, delete_set; LoopbackDescriptor loopback1, loopback2, loopback3; loopback1.Init(); loopback2.Init(); loopback3.Init(); OLA_ASSERT_TRUE(m_ss->AddWriteDescriptor(&loopback1)); OLA_ASSERT_TRUE(m_ss->AddWriteDescriptor(&loopback2)); OLA_ASSERT_TRUE(m_ss->AddWriteDescriptor(&loopback3)); write_set.insert(&loopback1); write_set.insert(&loopback2); write_set.insert(&loopback3); loopback1.SetOnWritable(NewCallback( this, &SelectServerTest::NullHandler)); loopback2.SetOnWritable(NewCallback( this, &SelectServerTest::RemoveAndDeleteDescriptors, read_set, write_set, delete_set)); loopback3.SetOnWritable(NewCallback( this, &SelectServerTest::NullHandler)); OLA_ASSERT_EQ(3, write_descriptor_count->Get()); OLA_ASSERT_EQ(1, connected_read_descriptor_count->Get()); m_ss->Run(); OLA_ASSERT_EQ(0, write_descriptor_count->Get()); OLA_ASSERT_EQ(1, connected_read_descriptor_count->Get()); OLA_ASSERT_EQ(0, read_descriptor_count->Get()); }
/* * Test non-blocking TCP connects work correctly. */ void TCPConnectorTest::testNonBlockingConnect() { ola::network::TCPSocketFactory socket_factory( ola::NewCallback(this, &TCPConnectorTest::AcceptedConnection)); TCPAcceptingSocket listening_socket(&socket_factory); IPV4SocketAddress listen_address(m_localhost, 0); OLA_ASSERT_TRUE_MSG(listening_socket.Listen(listen_address), "Failed to listen"); GenericSocketAddress addr = listening_socket.GetLocalAddress(); OLA_ASSERT_TRUE(addr.IsValid()); // calling listen a second time should fail OLA_ASSERT_FALSE(listening_socket.Listen(listen_address)); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(&listening_socket)); // now attempt a non-blocking connect // because we're connecting to the localhost this may run this callback // immediately. TCPConnector connector(m_ss); TimeInterval connect_timeout(0, CONNECT_TIMEOUT_IN_MS * 1000); TCPConnector::TCPConnectionID id = connector.Connect( addr.V4Addr(), connect_timeout, ola::NewSingleCallback(this, &TCPConnectorTest::OnConnect)); OLA_ASSERT_TRUE(id); m_ss->Run(); OLA_ASSERT_EQ(0u, connector.ConnectionsPending()); m_ss->RemoveReadDescriptor(&listening_socket); }
/* * Check that we don't invalid iterators by removing descriptors during an * on_read callback. */ void SelectServerTest::testRemoveOthersWhenReadable() { Descriptors read_set, write_set, delete_set; LoopbackDescriptor loopback1, loopback2, loopback3; loopback1.Init(); loopback2.Init(); loopback3.Init(); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(&loopback1)); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(&loopback2)); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(&loopback3)); read_set.insert(&loopback1); read_set.insert(&loopback2); read_set.insert(&loopback3); loopback2.SetOnClose(NewSingleCallback( this, &SelectServerTest::RemoveAndDeleteDescriptors, read_set, write_set, delete_set)); OLA_ASSERT_EQ(0, write_descriptor_count->Get()); OLA_ASSERT_EQ(4, connected_read_descriptor_count->Get()); loopback2.CloseClient(); m_ss->Run(); OLA_ASSERT_EQ(0, write_descriptor_count->Get()); OLA_ASSERT_EQ(1, connected_read_descriptor_count->Get()); OLA_ASSERT_EQ(0, read_descriptor_count->Get()); }
/* * Startup the server. */ int main(int argc, char *argv[]) { std::ostringstream help_msg; help_msg << "The OLA SLP client.\n" "\n" "Examples:\n" " " << argv[0] << " register service:myserv.x://myhost.com\n" " " << argv[0] << " findsrvs service:myserv.x\n" " " << argv[0] << " findsrvs service:myserv.x"; ola::AppInit(&argc, argv, "[options] command-and-arguments", help_msg.str()); vector<string> args; for (int i = 1; i < argc; i++) { args.push_back(argv[i]); } auto_ptr<Command> command(CreateCommand(args)); if (!command.get()) { ola::DisplayUsage(); exit(ola::EXIT_OK); } ola::slp::SLPClientWrapper client_wrapper; if (!client_wrapper.Setup()) exit(1); SelectServer *ss = client_wrapper.GetSelectServer(); command->SetTermination(NewCallback(ss, &SelectServer::Terminate)); if (!command->Execute(client_wrapper.GetClient())) exit(1); ss->Run(); }
/* * Test UDP sockets work correctly. * The client connects and the server sends some data. The client checks the * data matches and then closes the connection. */ void SocketTest::testUDPSocket() { IPV4SocketAddress socket_address(IPV4Address::Loopback(), 0); UDPSocket socket; OLA_ASSERT_TRUE(socket.Init()); OLA_ASSERT_FALSE(socket.Init()); OLA_ASSERT_TRUE(socket.Bind(socket_address)); OLA_ASSERT_FALSE(socket.Bind(socket_address)); IPV4SocketAddress local_address; OLA_ASSERT_TRUE(socket.GetSocketAddress(&local_address)); OLA_ASSERT_EQ(static_cast<uint16_t>(AF_INET), local_address.Family()); socket.SetOnData( ola::NewCallback(this, &SocketTest::UDPReceiveAndSend, &socket)); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(&socket)); UDPSocket client_socket; OLA_ASSERT_TRUE(client_socket.Init()); OLA_ASSERT_FALSE(client_socket.Init()); client_socket.SetOnData( ola::NewCallback( this, &SocketTest::UDPReceiveAndTerminate, static_cast<UDPSocket*>(&client_socket))); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(&client_socket)); ssize_t bytes_sent = client_socket.SendTo( static_cast<const uint8_t*>(test_cstring), sizeof(test_cstring), local_address); OLA_ASSERT_EQ(static_cast<ssize_t>(sizeof(test_cstring)), bytes_sent); m_ss->Run(); m_ss->RemoveReadDescriptor(&socket); m_ss->RemoveReadDescriptor(&client_socket); }
/** * Check that a callback from the SelectServer thread executes. */ void SelectServerThreadTest::testSameThreadCallback() { TestThread test_thread(&m_ss, ola::thread::Thread::Self()); m_ss.Execute( ola::NewSingleCallback(&test_thread, &TestThread::TestCallback)); OLA_ASSERT_FALSE(test_thread.CallbackRun()); m_ss.Run(); OLA_ASSERT_TRUE(test_thread.CallbackRun()); }
/* * Check that a callback from a different thread is executed in the * SelectServer thread. */ void SelectServerThreadTest::testDifferentThreadCallback() { TestThread test_thread(&m_ss, ola::thread::Thread::Self()); test_thread.Start(); OLA_ASSERT_FALSE(test_thread.CallbackRun()); m_ss.Run(); test_thread.Join(); OLA_ASSERT_TRUE(test_thread.CallbackRun()); }
/* * Check that method that fail return correctly */ void RpcChannelTest::testFailedEcho() { m_request.set_data("foo"); m_stub->FailedEcho( &m_controller, &m_request, &m_reply, NewSingleCallback(this, &RpcChannelTest::FailedEchoComplete)); m_ss.Run(); }
/* * Check that the loop closures are called. */ void SelectServerTest::testLoopCallbacks() { m_ss->SetDefaultInterval(ola::TimeInterval(0, 100000)); // poll every 100ms m_ss->RunInLoop( ola::NewCallback(this, &SelectServerTest::IncrementLoopCounter)); m_ss->RegisterSingleTimeout( 500, ola::NewSingleCallback(this, &SelectServerTest::Terminate)); m_ss->Run(); // we should have at least 5 calls to IncrementLoopCounter OLA_ASSERT_TRUE(m_loop_counter >= 5); }
/* * Flashes the device */ int main(int argc, char *argv[]) { options opts; opts.log_level = ola::OLA_LOG_WARN; opts.help = false; opts.firmware = DEFAULT_FIRMWARE; opts.device = DEFAULT_DEVICE; ParseOptions(argc, argv, &opts); if (opts.help) DisplayHelpAndExit(argv); ola::InitLogging(opts.log_level, ola::OLA_LOG_STDERR); ifstream firmware_file(opts.firmware.data()); if (!firmware_file.is_open()) { OLA_FATAL << "Can't open the firmware file " << opts.firmware << ": " << strerror(errno); exit(1); } SelectServer ss; ola::io::ConnectedDescriptor *descriptor = ola::plugin::usbpro::BaseUsbProWidget::OpenDevice(opts.device); if (!descriptor) exit(ola::EXIT_UNAVAILABLE); descriptor->SetOnClose(ola::NewSingleCallback(&Stop, &ss)); ss.AddReadDescriptor(descriptor); DispatchingUsbProWidget widget(descriptor, NULL); FirmwareTransferer transferer(&firmware_file, &widget, &ss); widget.SetHandler( ola::NewCallback(&transferer, &FirmwareTransferer::HandleMessage)); if (!transferer.SendReprogram()) { OLA_FATAL << "Send message failed"; exit(1); } ss.RegisterSingleTimeout( PAUSE_DELAY, ola::NewSingleCallback(&transferer, &FirmwareTransferer::StartTransfer)); widget.GetDescriptor()->SetOnClose( ola::NewSingleCallback(&transferer, &FirmwareTransferer::AbortTransfer)); ss.RegisterSingleTimeout( ABORT_TIMEOUT, ola::NewSingleCallback(&transferer, &FirmwareTransferer::AbortTransfer)); ss.Run(); firmware_file.close(); return !transferer.WasSucessfull(); }
/** * Test that pausing a connection works. */ void AdvancedTCPConnectorTest::testPause() { ola::network::TCPSocketFactory socket_factory( ola::NewCallback(this, &AdvancedTCPConnectorTest::AcceptedConnection)); TCPAcceptingSocket listening_socket(&socket_factory); SetupListeningSocket(&listening_socket); AdvancedTCPConnector connector( m_ss, m_tcp_socket_factory.get(), TimeInterval(0, CONNECT_TIMEOUT_IN_MS * 1000)); // 5 per attempt, up to a max of 30 LinearBackoffPolicy policy(TimeInterval(5, 0), TimeInterval(30, 0)); // add endpoint, but make sure it's paused connector.AddEndpoint(m_server_address, &policy, true); OLA_ASSERT_EQ(1u, connector.EndpointCount()); ConfirmState(__LINE__, connector, m_server_address, AdvancedTCPConnector::PAUSED, 0); m_ss->RunOnce(TimeInterval(0, 500000)); // now unpause connector.Resume(m_server_address); // The socket may be connected immediately depending on the platform. AdvancedTCPConnector::ConnectionState state; unsigned int failed_attempts; connector.GetEndpointState(m_server_address, &state, &failed_attempts); if (state == AdvancedTCPConnector::DISCONNECTED) { m_ss->Run(); } OLA_ASSERT_EQ(1u, connector.EndpointCount()); ConfirmState(__LINE__, connector, m_server_address, AdvancedTCPConnector::CONNECTED, 0); // check our socket exists OLA_ASSERT_TRUE(m_connected_socket); m_connected_socket->Close(); delete m_connected_socket; connector.Disconnect(m_server_address, true); // state should be updated ConfirmState(__LINE__, connector, m_server_address, AdvancedTCPConnector::PAUSED, 0); // clean up connector.RemoveEndpoint(m_server_address); OLA_ASSERT_EQ(0u, connector.EndpointCount()); m_ss->RemoveReadDescriptor(&listening_socket); }
/** * Test that pausing a connection works. */ void AdvancedTCPConnectorTest::testPause() { ola::network::TCPSocketFactory socket_factory( ola::NewCallback(this, &AdvancedTCPConnectorTest::AcceptedConnection)); TcpAcceptingSocket listening_socket(&socket_factory); SetupListeningSocket(&listening_socket); AdvancedTCPConnector connector( m_ss, m_tcp_socket_factory.get(), TimeInterval(0, CONNECT_TIMEOUT_IN_MS * 1000)); // 5 per attempt, up to a max of 30 LinearBackoffPolicy policy(TimeInterval(5, 0), TimeInterval(30, 0)); // add endpoint, but make sure it's paused connector.AddEndpoint(m_localhost, SERVER_PORT, &policy, true); CPPUNIT_ASSERT_EQUAL(1u, connector.EndpointCount()); ConfirmState(__LINE__, connector, m_localhost, SERVER_PORT, AdvancedTCPConnector::PAUSED, 0); m_ss->RunOnce(0, 500000); // now unpause connector.Resume(m_localhost, SERVER_PORT); ConfirmState(__LINE__, connector, m_localhost, SERVER_PORT, AdvancedTCPConnector::DISCONNECTED, 0); m_ss->Run(); CPPUNIT_ASSERT_EQUAL(1u, connector.EndpointCount()); ConfirmState(__LINE__, connector, m_localhost, SERVER_PORT, AdvancedTCPConnector::CONNECTED, 0); // check our socket exists CPPUNIT_ASSERT(m_connected_socket); m_connected_socket->Close(); delete m_connected_socket; OLA_INFO << "disconnecting"; connector.Disconnect(m_localhost, SERVER_PORT, true); // state should be updated ConfirmState(__LINE__, connector, m_localhost, SERVER_PORT, AdvancedTCPConnector::PAUSED, 0); // clean up connector.RemoveEndpoint(m_localhost, SERVER_PORT); CPPUNIT_ASSERT_EQUAL(0u, connector.EndpointCount()); m_ss->RemoveReadDescriptor(&listening_socket); }
/* * Main. */ int main(int argc, char *argv[]) { ola::AppInit(&argc, argv, "[ options ]", "Decode DMX/RDM data from a Saleae Logic device"); SelectServer ss; LogicReader reader(&ss, FLAGS_sample_rate); DevicesManagerInterface::RegisterOnConnect(&OnConnect, &reader); DevicesManagerInterface::RegisterOnDisconnect(&OnDisconnect, &reader); DevicesManagerInterface::BeginConnect(); OLA_INFO << "Running..."; ss.RegisterSingleTimeout(3000, NewSingleCallback(DisplayReminder, &reader)); ss.Run(); reader.Stop(); return ola::EXIT_OK; }
/* * Test a non-blocking TCP connect fails. */ void TCPConnectorTest::testNonBlockingConnectFailure() { uint16_t port = ReservePort(); OLA_ASSERT_NE(0, port); IPV4SocketAddress target(m_localhost, port); // attempt a non-blocking connect, hopefully nothing is running on port 9010 TCPConnector connector(m_ss); TimeInterval connect_timeout(0, CONNECT_TIMEOUT_IN_MS * 1000); TCPConnector::TCPConnectionID id = connector.Connect( target, connect_timeout, ola::NewSingleCallback(this, &TCPConnectorTest::OnConnectFailure)); OLA_ASSERT_TRUE(id); m_ss->Run(); OLA_ASSERT_EQ(0u, connector.ConnectionsPending()); }
/** * Check the channel works when every 2nd heartbeat is lost */ void HealthCheckedConnectionTest::testChannelWithPacketLoss() { options.send_every = 2; MockHealthCheckedConnection connection(&socket, &m_ss, heartbeat_interval, options, &m_clock); socket.SetOnData( NewCallback(&connection, &MockHealthCheckedConnection::ReadData)); connection.Setup(); m_ss.AddReadDescriptor(&socket); connection.Setup(); m_ss.Run(); OLA_ASSERT_TRUE(connection.ChannelOk()); }
/* * Check that the channel stays up when all heartbeats are received. */ void HealthCheckedConnectionTest::testSimpleChannel() { options.validate_heartbeat = true; MockHealthCheckedConnection connection(&socket, &m_ss, heartbeat_interval, options, &m_clock); socket.SetOnData( NewCallback(&connection, &MockHealthCheckedConnection::ReadData)); connection.Setup(); m_ss.AddReadDescriptor(&socket); connection.Setup(); m_ss.Run(); OLA_ASSERT_TRUE(connection.ChannelOk()); }
/* * Main. */ int main(int argc, char *argv[]) { ola::SetHelpString("[options]", "Decode DMX/RDM data from a Saleae Logic device"); ola::ParseFlags(&argc, argv); ola::InitLoggingFromFlags(); SelectServer ss; LogicReader reader(&ss, FLAGS_sample_rate); DevicesManagerInterface::RegisterOnConnect(&OnConnect, &reader); DevicesManagerInterface::RegisterOnDisconnect(&OnDisconnect, &reader); DevicesManagerInterface::BeginConnect(); OLA_INFO << "Running..."; ss.Run(); reader.Stop(); return ola::EXIT_OK; }
/* * Confirm we correctly detect the remote end closing the connection. * This uses the delete_on_close option. */ void SelectServerTest::testRemoteEndCloseWithDelete() { // Ownership is transferred to the SelectServer. LoopbackDescriptor *loopback_socket = new LoopbackDescriptor(); loopback_socket->Init(); loopback_socket->SetOnClose(NewSingleCallback( this, &SelectServerTest::Terminate)); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(loopback_socket, true)); OLA_ASSERT_EQ(2, connected_read_descriptor_count->Get()); OLA_ASSERT_EQ(0, read_descriptor_count->Get()); // Now the Write end closes loopback_socket->CloseClient(); m_ss->Run(); OLA_ASSERT_EQ(1, connected_read_descriptor_count->Get()); OLA_ASSERT_EQ(0, read_descriptor_count->Get()); }
/* * Confirm we correctly detect the remote end closing the connection. */ void SelectServerTest::testRemoteEndClose() { LoopbackDescriptor loopback_socket; loopback_socket.Init(); loopback_socket.SetOnClose(NewSingleCallback( this, &SelectServerTest::RemoveFromSelectServer, reinterpret_cast<ConnectedDescriptor*>(&loopback_socket))); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(&loopback_socket)); OLA_ASSERT_EQ(2, connected_read_descriptor_count->Get()); OLA_ASSERT_EQ(0, read_descriptor_count->Get()); // now the Write end closes loopback_socket.CloseClient(); m_ss->Run(); OLA_ASSERT_EQ(1, connected_read_descriptor_count->Get()); OLA_ASSERT_EQ(0, read_descriptor_count->Get()); }
int main(int argc, char* argv[]) { ola::AppInit(&argc, argv, "", "Run the E1.31 load test."); if (FLAGS_universes == 0 || FLAGS_fps == 0) return -1; unsigned int fps = min(1000u, static_cast<unsigned int>(FLAGS_fps)); uint16_t universes = FLAGS_universes; DmxBuffer output; output.Blackout(); Interface iface; { auto_ptr<InterfacePicker> picker(InterfacePicker::NewPicker()); if (!picker->ChooseInterface(&iface, FLAGS_interface.str())) { return -1; } } ArtNetNodeOptions options; options.always_broadcast = true; SelectServer ss; ArtNetNode node(iface, &ss, options); for (uint16_t i = 0; i < universes; i++) { if (!node.SetInputPortUniverse(i, i)) { OLA_WARN << "Failed to set port"; } } if (!node.Start()) return -1; ss.RegisterRepeatingTimeout( 1000 / fps, NewCallback(&SendFrames, &node, &output, universes)); cout << "Starting loadtester: " << universes << " universe(s), " << fps << " fps" << endl; ss.Run(); }
/* * Test the interaction between read and write descriptor. */ void SelectServerTest::testReadWriteInteraction() { UnixSocket socket; socket.Init(); socket.SetOnClose(NewSingleCallback(this, &SelectServerTest::Terminate)); OLA_ASSERT_TRUE(m_ss->AddReadDescriptor(&socket)); OLA_ASSERT_TRUE(m_ss->AddWriteDescriptor(&socket)); m_ss->RemoveWriteDescriptor(&socket); // now the Write end closes auto_ptr<UnixSocket> other_end(socket.OppositeEnd()); other_end->CloseClient(); m_ss->RegisterSingleTimeout( 100, ola::NewSingleCallback(this, &SelectServerTest::FatalTimeout)); m_ss->Run(); m_ss->RemoveReadDescriptor(&socket); OLA_ASSERT_EQ(1, connected_read_descriptor_count->Get()); OLA_ASSERT_EQ(0, read_descriptor_count->Get()); }
/* * Check that RemoveWriteDescriptor is reentrant. * We use the Execute() method to close a write descriptor during the same * cycle in which it becomes writeable. See * https://github.com/OpenLightingProject/ola/pull/429 for details. */ void SelectServerTest::testRemoveWriteWhenOtherReadable() { Descriptors read_set, write_set, delete_set; LoopbackDescriptor *loopback = new LoopbackDescriptor(); loopback->Init(); loopback->SetOnWritable(NewCallback(this, &SelectServerTest::NullHandler)); write_set.insert(loopback); delete_set.insert(loopback); OLA_ASSERT_TRUE(m_ss->AddWriteDescriptor(loopback)); OLA_ASSERT_EQ(1, write_descriptor_count->Get()); OLA_ASSERT_EQ(0, read_descriptor_count->Get()); m_ss->Execute(NewSingleCallback( this, &SelectServerTest::RemoveAndDeleteDescriptors, read_set, write_set, delete_set)); m_ss->Run(); OLA_ASSERT_EQ(0, write_descriptor_count->Get()); OLA_ASSERT_EQ(1, connected_read_descriptor_count->Get()); OLA_ASSERT_EQ(0, read_descriptor_count->Get()); }
/* * Main */ int main(int argc, char *argv[]) { ola::InitLogging(ola::OLA_LOG_INFO, ola::OLA_LOG_STDERR); udp_socket.SetOnData(ola::NewCallback(&SocketReady)); if (!udp_socket.Init()) { OLA_WARN << "Failed to init"; return 1; } if (!udp_socket.Bind(6038)) { OLA_WARN << "Failed to bind"; return 1; } if (!udp_socket.EnableBroadcast()) { OLA_WARN << "Failed to enabl bcast"; return 1; } ss.AddSocket(&udp_socket); ss.Run(); return 0; }