/*
* 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;
}
