test_server_thread.h

Go to the documentation of this file.

/*
 * @brief sim_loc_test_server_thread implements a simple tcp server thread,
 * simulating a localization controller for unittests. It runs a thread to listen
 * and accept tcp connections from clients and generates telegrams to test
 * the ros driver for sim localization.
 *
 * Copyright (C) 2019 Ing.-Buero Dr. Michael Lehning, Hildesheim
 * Copyright (C) 2019 SICK AG, Waldkirch
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of SICK AG nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission
 *     * Neither the name of Ing.-Buero Dr. Michael Lehning nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 *      Authors:
 *         Michael Lehning <michael.lehning@lehning.de>
 *
 *  Copyright 2019 SICK AG
 *  Copyright 2019 Ing.-Buero Dr. Michael Lehning
 *
 */
#ifndef __SIM_LOC_TEST_SERVER_THREAD_H_INCLUDED
#define __SIM_LOC_TEST_SERVER_THREAD_H_INCLUDED

#include <boost/asio/buffer.hpp>
#include <boost/asio/io_service.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/read.hpp>
#include <boost/asio/write.hpp>
#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <list>

#include "sick_scan/fifo_buffer.h"
#include "sick_scan/utils.h"

namespace sick_scan
{
  class TestServerThread
  {
  public:
    
    TestServerThread(ROS::NodePtr nh = 0, int ip_port_results = 2201, int ip_port_cola = 2111);
  
    virtual ~TestServerThread();
  
    virtual bool start(void);
  
    virtual bool stop(void);

    void messageCbResultPortTelegrams(const sick_scan::SickLocResultPortTelegramMsg & msg);
    virtual void messageCbResultPortTelegramsROS2(const std::shared_ptr<sick_scan::SickLocResultPortTelegramMsg> msg) { messageCbResultPortTelegrams(*msg); }
    
  protected:
  
    class ServerColaRequest
    {
    public:
      ServerColaRequest(const std::vector<uint8_t> & data = std::vector<uint8_t>(), bool ascii = false) : telegram_data(data), telegram_is_ascii(ascii) {} 
      bool telegram_is_ascii;             
      std::vector<uint8_t> telegram_data; 
    };
  
    typedef boost::thread* thread_ptr;                
    typedef boost::asio::ip::tcp::socket* socket_ptr; 
    
    void closeScandataThread(void);

    virtual void closeTcpConnections(bool force_shutdown = false);

    void closeSocket(socket_ptr & p_socket);
    
    void closeWorkerThreads(void);
    
    virtual void runConnectionThreadResultCb(void);
  
    virtual void runConnectionThreadColaCb(void);
  
    template<typename Callable> void runConnectionThreadGenericCb(boost::asio::ip::tcp::acceptor & tcp_acceptor_results, int ip_port_results, Callable thread_function_cb);
  
    virtual void runWorkerThreadResultCb(boost::asio::ip::tcp::socket* p_socket);
  
    virtual void runWorkerThreadColaCb(boost::asio::ip::tcp::socket* p_socket);

    virtual void runWorkerThreadScandataCb(boost::asio::ip::tcp::socket* p_socket);
  
    virtual void runErrorSimulationThreadCb(void);

    void errorSimulationWait(double seconds);

    bool errorSimulationWaitForTelegramReceived(double timeout_seconds, sick_scan::SickLocResultPortTelegramMsg & telegram_msg);
    
    /*
     * member data
     */

    int m_ip_port_results;                                   
    int m_ip_port_cola;                                      
    double m_result_telegram_rate;                           
    thread_ptr m_tcp_connection_thread_results;              
    thread_ptr m_tcp_connection_thread_cola;                 
    thread_ptr m_tcp_send_scandata_thread;                   
    bool m_tcp_send_scandata_thread_running;                 
    double m_start_scandata_delay;                           
    bool m_tcp_connection_thread_running;                    
    boost::asio::io_service m_ioservice;                     
    boost::asio::ip::tcp::acceptor m_tcp_acceptor_results;   
    boost::asio::ip::tcp::acceptor m_tcp_acceptor_cola;      
    std::list<boost::asio::ip::tcp::socket*> m_tcp_sockets;  
    std::list<thread_ptr> m_tcp_worker_threads;              
    boost::mutex m_tcp_worker_threads_mutex;                 
    bool m_worker_thread_running;                            
    sick_scan::SickLocResultPortTestcaseMsgPublisher m_result_testcases_publisher;  
    std::string m_result_testcases_frame_id;                 
    bool m_demo_move_in_circles;                             
    std::string m_scandatafiles;                             
    std::string m_scandatatypes;                             
    std::string m_scanner_type;                              

    /*
     * configuration and member data for error simulation
     */

    typedef enum ERROR_SIMULATION_ENUM 
    {
      NO_ERROR = 0,                
      DONT_LISTEN,                 
      DONT_ACCECPT,                
      DONT_SEND,                   
      SEND_RANDOM_TCP,             
      SEND_INVALID_TELEGRAMS       
    } ERROR_SIMULATION_FLAG;
  
    sick_scan::SetGet<ERROR_SIMULATION_FLAG> m_error_simulation_flag; 
    bool m_error_simulation_enabled;                         
    thread_ptr m_error_simulation_thread;                    
    bool m_error_simulation_thread_running;                  
    sick_scan::SetGet<sick_scan::SickLocResultPortTelegramMsg> m_last_telegram_received; 
    
  };
  
} // namespace sick_scan
#endif // __SIM_LOC_TEST_SERVER_THREAD_H_INCLUDED