void SimpleE133Device::OnTCPConnect(TCPSocket *socket) { OLA_INFO << "Opened new TCP connection: " << socket; m_socket.reset(socket); m_in_transport.reset(new IncomingTCPTransport(&m_root_inflator, socket)); m_message_queue.reset( new MessageQueue(m_socket.get(), &m_ss, m_message_builder.pool())); m_health_checked_connection.reset(new E133HealthCheckedConnection( &m_message_builder, m_message_queue.get(), NewSingleCallback(this, &SimpleE133Device::SocketClosed), &m_ss)); socket->SetOnData(NewCallback(this, &SimpleE133Device::ReceiveTCPData)); socket->SetOnClose(NewSingleCallback(this, &SimpleE133Device::SocketClosed)); m_ss.AddReadDescriptor(socket); if (!m_health_checked_connection->Setup()) { OLA_WARN << "Failed to setup heartbeat controller for " << m_controller; SocketClosed(); return; } }
/* * 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()); }
StageProfiDetector::StageProfiDetector(SelectServerInterface *ss, const vector<string> &widget_paths, WidgetCallback *callback) : m_ss(ss), m_callback(callback), m_timeout_id(INVALID_TIMEOUT), m_backoff(TimeInterval(1, 0), TimeInterval(300, 0)), m_socket_factory(NewCallback(this, &StageProfiDetector::SocketConnected)), m_tcp_connector(ss, &m_socket_factory, TimeInterval(3, 0)) { if (!callback) { OLA_FATAL << "No WidgetCallback provided"; return; } set<string> paths(widget_paths.begin(), widget_paths.end()); set<string>::const_iterator iter = paths.begin(); for (; iter != paths.end(); ++iter) { if (iter->empty()) { continue; } if (iter->at(0) == ola::file::PATH_SEPARATOR) { STLReplace(&m_usb_widgets, *iter, NULL); } else { IPV4SocketAddress socket_addr; if (EndpointFromString(*iter, &socket_addr)) { m_tcp_connector.AddEndpoint(socket_addr, &m_backoff); } } } }
/* * Test the Method Callbacks */ void CallbackTest::testMethodCallbacks4() { // test 2 arg callbacks that return unsigned ints BaseCallback4<void, unsigned int, int, char, const string&> *c1 = NewSingleCallback( this, &CallbackTest::Method4); c1->Run(TEST_INT_VALUE, TEST_INT_VALUE2, TEST_CHAR_VALUE, TEST_STRING_VALUE); BaseCallback4<void, unsigned int, int, char, const string&> *c2 = NewCallback( this, &CallbackTest::Method4); c2->Run(TEST_INT_VALUE, TEST_INT_VALUE2, TEST_CHAR_VALUE, TEST_STRING_VALUE); c2->Run(TEST_INT_VALUE, TEST_INT_VALUE2, TEST_CHAR_VALUE, TEST_STRING_VALUE); delete c2; // test 2 arg callbacks that return bools BaseCallback4<bool, unsigned int, int, char, const string&> *c3 = NewSingleCallback( this, &CallbackTest::BoolMethod4); OLA_ASSERT_TRUE(c3->Run(TEST_INT_VALUE, TEST_INT_VALUE2, TEST_CHAR_VALUE, TEST_STRING_VALUE)); BaseCallback4<bool, unsigned int, int, char, const string&> *c4 = NewCallback( this, &CallbackTest::BoolMethod4); OLA_ASSERT_TRUE(c4->Run(TEST_INT_VALUE, TEST_INT_VALUE2, TEST_CHAR_VALUE, TEST_STRING_VALUE)); OLA_ASSERT_TRUE(c4->Run(TEST_INT_VALUE, TEST_INT_VALUE2, TEST_CHAR_VALUE, TEST_STRING_VALUE)); delete c4; }
/** * Create a new DesignatedControllerConnection. * This listens for connections from the controllers, and will ensure that if * any controllers try to connect, at least one will be picked as the * designated controller. */ DesignatedControllerConnection::DesignatedControllerConnection( ola::io::SelectServerInterface *ss, const IPV4Address &ip_address, ola::e133::MessageBuilder *message_builder, TCPConnectionStats *tcp_stats, unsigned int max_queue_size) : m_ip_address(ip_address), m_max_queue_size(max_queue_size), m_ss(ss), m_message_builder(message_builder), m_tcp_stats(tcp_stats), m_tcp_socket(NULL), m_health_checked_connection(NULL), m_message_queue(NULL), m_incoming_tcp_transport(NULL), m_tcp_socket_factory( NewCallback(this, &DesignatedControllerConnection::NewTCPConnection)), m_listening_tcp_socket(&m_tcp_socket_factory), m_root_inflator( NewCallback(this, &DesignatedControllerConnection::RLPDataReceived)), m_unsent_messages(false) { m_root_inflator.AddInflator(&m_e133_inflator); m_e133_inflator.AddInflator(&m_e133_status_inflator); m_e133_status_inflator.SetStatusHandler( NewCallback(this, &DesignatedControllerConnection::HandleStatusMessage)); }
/** * Create a new E133Receiver. * @param socket the UDP socket to read from * @param status_callback the callback to run when status messages are * received. * @param rdm_callback the callback to run when RDM messages are received. */ E133Receiver::E133Receiver(ola::network::UDPSocket *socket, StatusCallback *status_callback, RDMCallback *rdm_callback) : m_udp_socket(socket), m_status_callback(status_callback), m_rdm_callback(rdm_callback), m_root_inflator(new plugin::e131::RootInflator()), m_e133_inflator(new plugin::e131::E133Inflator()), m_rdm_inflator(new plugin::e131::RDMInflator()), m_e133_status_inflator(new plugin::e131::E133StatusInflator()), m_incoming_udp_transport( new plugin::e131::IncomingUDPTransport( m_udp_socket, m_root_inflator.get())) { m_root_inflator->AddInflator(m_e133_inflator.get()); m_e133_inflator->AddInflator(m_rdm_inflator.get()); m_e133_inflator->AddInflator(m_e133_status_inflator.get()); m_rdm_inflator->SetRDMHandler( NewCallback(this, &E133Receiver::HandlePacket)); m_e133_status_inflator->SetStatusHandler( NewCallback(this, &E133Receiver::HandleStatusMessage)); m_udp_socket->SetOnData( NewCallback(m_incoming_udp_transport.get(), &ola::plugin::e131::IncomingUDPTransport::Receive)); }
/* * Fetch the state of a plugin. */ int FetchPluginState(OlaClientWrapper *wrapper, const options &opts) { SelectServer *ss = wrapper->GetSelectServer(); OlaClient *client = wrapper->GetClient(); if (opts.plugin_id == 0) { DisplayPluginStateHelp(opts); exit(1); } if (!opts.state.empty()) { bool state; if (ola::StringToBoolTolerant(opts.state, &state)) { cout << "Setting state to " << (state ? "enabled" : "disabled") << endl; client->SetPluginState( (ola::ola_plugin_id) opts.plugin_id, state, NewSingleCallback(&HandleAck, ss)); } else { cerr << "Invalid state: " << opts.state << endl; DisplayPluginStateHelp(opts); exit(1); } } else { client->FetchPluginState((ola::ola_plugin_id) opts.plugin_id, NewSingleCallback(&DisplayPluginState, ss)); } return 0; }
/** * 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 the IntToString function. */ void StringUtilsTest::testIntToString() { OLA_ASSERT_EQ(string("0"), IntToString(0)); OLA_ASSERT_EQ(string("1234"), IntToString(1234)); OLA_ASSERT_EQ(string("-1234"), IntToString(-1234)); unsigned int i = 42; OLA_ASSERT_EQ(string("42"), IntToString(i)); }
void StringUtilsTest::testFormatData() { uint8_t data[] = {0, 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', 1, 2}; std::stringstream str; FormatData(&str, data, sizeof(data)); OLA_ASSERT_EQ( string("00 48 65 6c 6c 6f 20 57 .Hello W\n" "6f 72 6c 64 01 02 orld..\n"), str.str()); // try 4 bytes per line with a 2 space indent str.str(""); FormatData(&str, data, sizeof(data), 2, 4); OLA_ASSERT_EQ( string(" 00 48 65 6c .Hel\n" " 6c 6f 20 57 lo W\n" " 6f 72 6c 64 orld\n" " 01 02 ..\n"), str.str()); str.str(""); // try ending on the block boundary uint8_t data1[] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o'}; FormatData(&str, data1, sizeof(data1), 0, 4); OLA_ASSERT_EQ( string("48 65 6c 6c Hell\n" "6f 20 57 6f o Wo\n"), str.str()); }
/* * Check that queued messages work. */ void DmxTriWidgetTest::testQueuedMessages() { UID source(1, 2); UID destination(0x707a, 0xffffff00); vector<string> packets; PopulateTod(); // first try a response which is too short const RDMRequest *request = NewQueuedMessageRequest(source, destination, 1); uint8_t expected_rdm_command[] = {0x3a, 0x02, 0x01}; uint8_t small_response[] = {0x3a, 0x04}; m_endpoint->AddExpectedUsbProDataAndReturn( EXTENDED_LABEL, expected_rdm_command, sizeof(expected_rdm_command), EXTENDED_LABEL, small_response, sizeof(small_response)); m_widget->SendRDMRequest( request, NewSingleCallback(this, &DmxTriWidgetTest::ValidateStatus, ola::rdm::RDM_INVALID_RESPONSE, packets)); m_ss.Run(); m_endpoint->Verify(); // now try a proper response request = NewQueuedMessageRequest(source, destination, 1); uint8_t queued_response[] = {0x3a, 0x00, 0x00, 0x60, 0x52}; m_endpoint->AddExpectedUsbProDataAndReturn( EXTENDED_LABEL, expected_rdm_command, sizeof(expected_rdm_command), EXTENDED_LABEL, queued_response, sizeof(queued_response)); uint8_t return_data = 0x52; ola::rdm::RDMGetResponse response( destination, source, 0, // transaction # ola::rdm::RDM_ACK, 0, // message count 10, // sub device 0x0060, // param id &return_data, sizeof(return_data)); // data length m_widget->SendRDMRequest( request, NewSingleCallback(this, &DmxTriWidgetTest::ValidateResponse, ola::rdm::RDM_COMPLETED_OK, static_cast<const RDMResponse*>(&response), packets)); m_ss.Run(); m_endpoint->Verify(); }
void ArtNetInputPort::PostSetUniverse(Universe *old_universe, Universe *new_universe) { if (new_universe) m_node->SetOutputPortUniverse(PortId(), new_universe->UniverseId() % 0xf); else m_node->DisableOutputPort(PortId()); if (new_universe && !old_universe) { m_node->SetDMXHandler( PortId(), &m_buffer, NewCallback(static_cast<ola::BasicInputPort*>(this), &ArtNetInputPort::DmxChanged)); m_node->SetOutputPortRDMHandlers( PortId(), NewCallback( this, &ArtNetInputPort::RespondWithTod), NewCallback( this, &ArtNetInputPort::TriggerDiscovery), ola::NewCallback( static_cast<ola::BasicInputPort*>(this), &ArtNetInputPort::HandleRDMRequest)); } else if (!new_universe) { m_node->SetDMXHandler(PortId(), NULL, NULL); m_node->SetOutputPortRDMHandlers(PortId(), NULL, NULL, NULL); } if (new_universe) TriggerRDMDiscovery( NewSingleCallback(this, &ArtNetInputPort::SendTODWithUIDs)); }
/* * 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()); }
bool ArtNetDevice::StartHook() { unsigned int subnet = 0; StringToInt(m_preferences->GetValue(K_SUBNET_KEY), &subnet); unsigned int net; StringToInt(m_preferences->GetValue(K_NET_KEY), &net); ola::network::Interface interface; auto_ptr<ola::network::InterfacePicker> picker( ola::network::InterfacePicker::NewPicker()); ola::network::InterfacePicker::Options options; options.include_loopback = m_preferences->GetValueAsBool(K_LOOPBACK_KEY); if (!picker->ChooseInterface( &interface, m_preferences->GetValue(K_IP_KEY), options)) { OLA_INFO << "Failed to find an interface"; return false; } ArtNetNodeOptions node_options; node_options.always_broadcast = m_preferences->GetValueAsBool( K_ALWAYS_BROADCAST_KEY); node_options.use_limited_broadcast_address = m_preferences->GetValueAsBool( K_LIMITED_BROADCAST_KEY); // OLA Output ports are ArtNet input ports StringToInt(m_preferences->GetValue(K_OUTPUT_PORT_KEY), &node_options.input_port_count); m_node = new ArtNetNode(interface, m_plugin_adaptor, node_options); m_node->SetNetAddress(net); m_node->SetSubnetAddress(subnet); m_node->SetShortName(m_preferences->GetValue(K_SHORT_NAME_KEY)); m_node->SetLongName(m_preferences->GetValue(K_LONG_NAME_KEY)); for (unsigned int i = 0; i < node_options.input_port_count; i++) { AddPort(new ArtNetOutputPort(this, i, m_node)); } for (unsigned int i = 0; i < ARTNET_MAX_PORTS; i++) { AddPort(new ArtNetInputPort(this, i, m_plugin_adaptor, m_node)); } if (!m_node->Start()) { DeleteAllPorts(); delete m_node; m_node = NULL; return false; } ostringstream str; str << K_DEVICE_NAME << " [" << interface.ip_address << "]"; SetName(str.str()); m_timeout_id = m_plugin_adaptor->RegisterRepeatingTimeout( POLL_INTERVAL, NewCallback(m_node, &ArtNetNode::SendPoll)); return true; }
/* * Test the StringEndsWith function. */ void StringUtilsTest::testEndsWith() { string input = "foo bar baz"; OLA_ASSERT_TRUE(StringEndsWith(input, "baz")); OLA_ASSERT_TRUE(StringEndsWith(input, " baz")); OLA_ASSERT_TRUE(StringEndsWith(input, "bar baz")); OLA_ASSERT_TRUE(StringEndsWith(input, "")); OLA_ASSERT_FALSE(StringEndsWith(input, "foo")); }
/* * Check that nacks work as expected. */ void DmxTriWidgetTest::testNack() { UID source(1, 2); UID destination(0x707a, 0xffffff00); PopulateTod(); RDMRequest *request = NewRequest(source, destination, NULL, 0); uint8_t expected_rdm_command[] = {0x38, 0x02, 0x00, 0x0a, 0x01, 0x28}; uint8_t nack_pid_response[] = {0x38, 0x20}; // unknown pid m_endpoint->AddExpectedUsbProDataAndReturn( EXTENDED_LABEL, expected_rdm_command, sizeof(expected_rdm_command), EXTENDED_LABEL, nack_pid_response, sizeof(nack_pid_response)); RDMResponse *response = ola::rdm::NackWithReason( request, ola::rdm::NR_UNKNOWN_PID); m_widget->SendRDMRequest( request, NewSingleCallback(this, &DmxTriWidgetTest::ValidateResponse, ola::rdm::RDM_COMPLETED_OK, static_cast<const RDMResponse*>(response))); m_ss.Run(); m_endpoint->Verify(); delete response; // try a proxy buffer full request = NewRequest(source, destination, NULL, 0); uint8_t nack_proxy_response[] = {0x38, 0x2a}; // bad proxy m_endpoint->AddExpectedUsbProDataAndReturn( EXTENDED_LABEL, expected_rdm_command, sizeof(expected_rdm_command), EXTENDED_LABEL, nack_proxy_response, sizeof(nack_proxy_response)); response = ola::rdm::NackWithReason( request, ola::rdm::NR_PROXY_BUFFER_FULL); m_widget->SendRDMRequest( request, NewSingleCallback(this, &DmxTriWidgetTest::ValidateResponse, ola::rdm::RDM_COMPLETED_OK, static_cast<const RDMResponse*>(response))); m_ss.Run(); m_endpoint->Verify(); delete response; }
/** * Send a block of PDUs */ void TCPTransportTest::testSinglePDUBlock() { SendPDUBlock(OLA_SOURCELINE()); m_ss->RunOnce(TimeInterval(1, 0)); m_loopback.CloseClient(); m_ss->RunOnce(TimeInterval(1, 0)); OLA_ASSERT(m_stream_ok); OLA_ASSERT_EQ(3u, m_pdus_received); }
void OnTCPConnect(TCPSocket *socket) { OLA_INFO << "New connection: " << socket; socket->SetOnData( NewCallback(this, &Server::ReceiveTCPData, socket)); socket->SetOnClose( NewSingleCallback(this, &Server::SocketClosed, socket)); m_ss.AddReadDescriptor(socket); m_sockets.push_back(socket); }
/** * Test a 0-length PDU block */ void TCPTransportTest::testZeroLengthPDUBlock() { SendEmptyPDUBLock(OLA_SOURCELINE()); SendPDU(OLA_SOURCELINE()); m_ss->RunOnce(TimeInterval(1, 0)); m_loopback.CloseClient(); m_ss->RunOnce(TimeInterval(1, 0)); OLA_ASSERT(m_stream_ok); OLA_ASSERT_EQ(1u, m_pdus_received); }
/* * Check that attempting a discovery while another is running fails. */ void QueueingRDMControllerTest::testMultipleDiscovery() { MockRDMController mock_controller; auto_ptr<ola::rdm::DiscoverableQueueingRDMController> controller( new ola::rdm::DiscoverableQueueingRDMController(&mock_controller, 1)); UIDSet uids, uids2; UID uid1(2, 3); UID uid2(10, 11); UID uid3(20, 22); UID uid4(65, 45); uids.AddUID(uid1); uids.AddUID(uid2); uids2.AddUID(uid3); uids2.AddUID(uid4); // trigger discovery, this doesn't run the callback immediately mock_controller.AddExpectedDiscoveryCall(true, NULL); controller->RunFullDiscovery( NewSingleCallback( this, &QueueingRDMControllerTest::VerifyDiscoveryComplete, &uids)); mock_controller.Verify(); OLA_ASSERT_FALSE(m_discovery_complete_count); // trigger discovery again, this should queue the discovery request controller->RunIncrementalDiscovery( NewSingleCallback( this, &QueueingRDMControllerTest::VerifyDiscoveryComplete, &uids2)); mock_controller.Verify(); // and again controller->RunIncrementalDiscovery( NewSingleCallback( this, &QueueingRDMControllerTest::VerifyDiscoveryComplete, &uids2)); mock_controller.Verify(); // return from the first one, this will trigger the second discovery call mock_controller.AddExpectedDiscoveryCall(false, NULL); mock_controller.RunDiscoveryCallback(uids); OLA_ASSERT_TRUE(m_discovery_complete_count); m_discovery_complete_count = 0; mock_controller.Verify(); // now return from the second one, which should complete the 2nd and 3rd // requests mock_controller.RunDiscoveryCallback(uids2); OLA_ASSERT_EQ(2, m_discovery_complete_count); m_discovery_complete_count = 0; mock_controller.Verify(); }
/** * Test the MultiCallback works with a 0 limit */ void MultiCallbackTest::testZeroLimit() { BaseCallback0<void> *callback = NewSingleCallback( this, &MultiCallbackTest::CallbackMethod); CPPUNIT_ASSERT_EQUAL(0, m_callback_count); BaseCallback0<void> *multi_callback = NewMultiCallback(0, callback); CPPUNIT_ASSERT_EQUAL(1, m_callback_count); (void) multi_callback; }
/* * Test the shorten function. */ void StringUtilsTest::testShorten() { string input = "foo bar baz"; ShortenString(&input); OLA_ASSERT_EQ(string("foo bar baz"), input); input = "foo \0bar"; ShortenString(&input); OLA_ASSERT_EQ(string("foo "), input); input = "foo\0bar\0baz"; StringTrim(&input); OLA_ASSERT_EQ(string("foo"), input); }
/* * Test the trim function. */ void StringUtilsTest::testTrim() { string input = "foo bar baz"; StringTrim(&input); OLA_ASSERT_EQ(string("foo bar baz"), input); input = " \rfoo bar\t\n"; StringTrim(&input); OLA_ASSERT_EQ(string("foo bar"), input); input = " \r\t\n"; StringTrim(&input); OLA_ASSERT_EQ(string(""), input); }
/** * Test the MultiCallback works with a single limit */ void MultiCallbackTest::testSingleLimit() { BaseCallback0<void> *callback = NewSingleCallback( this, &MultiCallbackTest::CallbackMethod); CPPUNIT_ASSERT_EQUAL(0, m_callback_count); BaseCallback0<void> *multi_callback = NewMultiCallback(1, callback); CPPUNIT_ASSERT_EQUAL(0, m_callback_count); multi_callback->Run(); CPPUNIT_ASSERT_EQUAL(1, m_callback_count); }
/** * Test a short preamble. */ void TCPTransportTest::testShortPreamble() { uint8_t bogus_data[] = { 1, 2, 3, 4, 1, 2, 3, 4}; m_loopback.Send(bogus_data, sizeof(bogus_data)); m_ss->RunOnce(TimeInterval(1, 0)); m_loopback.CloseClient(); m_ss->RunOnce(TimeInterval(1, 0)); OLA_ASSERT(m_stream_ok); OLA_ASSERT_EQ(0u, m_pdus_received); }
void RunDiscovery(bool incremental) { JaRuleWidget *widget = m_widget_manager->GetWidget(); if (!widget) { return; } if (incremental) { widget->RunIncrementalDiscovery( NewSingleCallback(this, &InputHandler::DiscoveryComplete)); } else { widget->RunFullDiscovery( NewSingleCallback(this, &InputHandler::DiscoveryComplete)); } }
void StringUtilsTest::testStringJoin() { vector<int> ints; ints.push_back(1); ints.push_back(2); ints.push_back(3); OLA_ASSERT_EQ(string("1,2,3"), StringJoin(",", ints)); vector<string> strings; strings.push_back("one"); strings.push_back("two"); strings.push_back("three"); OLA_ASSERT_EQ(string("one,two,three"), StringJoin(",", strings)); }
SimpleE133Device::SimpleE133Device(const Options &options) : m_controller(options.controller), m_message_builder(ola::acn::CID::Generate(), "E1.33 Device"), m_tcp_socket_factory(NewCallback(this, &SimpleE133Device::OnTCPConnect)), m_connector(&m_ss, &m_tcp_socket_factory, TimeInterval(FLAGS_tcp_connect_timeout_ms / 1000, (FLAGS_tcp_connect_timeout_ms % 1000) * 1000)), m_backoff_policy(TimeInterval( FLAGS_tcp_retry_interval_ms / 1000, (FLAGS_tcp_retry_interval_ms % 1000) * 1000)), m_root_inflator(NewCallback(this, &SimpleE133Device::RLPDataReceived)) { m_connector.AddEndpoint(options.controller, &m_backoff_policy); }
/* * Fetch information on plugins. */ int FetchPluginInfo(OlaCallbackClientWrapper *wrapper, const options &opts) { SelectServer *ss = wrapper->GetSelectServer(); OlaCallbackClient *client = wrapper->GetClient(); if (opts.plugin_id > 0) { client->FetchPluginDescription( (ola::ola_plugin_id) opts.plugin_id, NewSingleCallback(&DisplayPluginDescription, ss)); } else { client->FetchPluginList( NewSingleCallback(&DisplayPlugins, ss, opts.list_plugin_ids)); } return 0; }
/** * 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); }