content_server 1.1.0 → 1.2.0

data/lib/testing_server/testing_server.rb

@@ -0,0 +1,236 @@
+#require 'net/sftp'
+#require 'net/ssh'
+require 'log4r'
+require 'log'
+require 'params'
+require 'content_server'
+require 'content_server/content_server'  # specific content server impl
+require 'content_server/backup_server' # specific backup server impl
+require 'content_data'
+require 'email'
+require 'file_utils/file_generator/file_generator'
+require 'validations'
+
+# Testing server. Assumes that content and backup servers are running.
+# The server runs 24-7, generates/deletes files and validates content at backup periodically.
+module TestingServer
+  # TODO get latest ContentData object directly from Content/BackupServer
+  # Then need changes in Content/BackupServers API
+  # TODO split to Backup/ContentTestingServers separate classes ?
+  # TODO split long methods
+  # TODO Tests
+  # TODO No default config taken by Params
+  # TODO Additional testing scenarios (remove/rename/change)
+
+  # Messages types
+  :GET_INDEX  # get index from remote master
+  :PUT_INDEX  # message contains requested index from master
+  # TODO in thus implementation validation called automatically on master side
+  # with receiving GET_INDEX message
+  # More flexible will be separating it to two separate operations:
+  # GET_INDEX and VALIDATE
+  #:VALIDATE  # validate index on master
+  :PUT_VALIDATION  # message contains validation result from master
+
+  Params.path('testing_log_path', nil, 'Testing server log path.')
+
+  # init process vars
+  $objects_counters = {}
+  $objects_counters["Time"] = Time.now.to_i
+
+  def init_log4r
+    #init log4r
+    log_path = Params['testing_log_path']
+    unless log_path
+      raise("pls specify testing log path through param:'testing_log_path'")
+    end
+    log_dir = File.dirname(log_path)
+    FileUtils.mkdir_p(log_dir) unless File.exists?(log_dir)
+
+    $log4r = Log4r::Logger.new 'BBFS testing server log'
+    $log4r.trace = true
+    formatter = Log4r::PatternFormatter.new(:pattern => "[%d] [%m]")
+    #file setup
+    file_config = {
+        "filename" => Params['testing_log_path'],
+        "maxsize" => Params['log_rotation_size'],
+        "trunc" => true
+    }
+    file_outputter = Log4r::RollingFileOutputter.new("testing_log", file_config)
+    file_outputter.level = Log4r::INFO
+    file_outputter.formatter = formatter
+    $log4r.outputters << file_outputter
+  end
+
+  def run_content_testing_server
+    Log.info('Testing server started')
+    init_log4r
+    $log4r.info 'Testing server started'
+    all_threads = [];
+    messages = Queue.new
+
+    all_threads << Thread.new do
+      ContentServer.run_content_server
+    end
+
+    all_threads << Thread.new do
+      fg = FileGenerator::FileGenerator.new
+      fg.run
+    end
+
+    receive_msg_proc = lambda do |addr_info, message|
+      $log4r.info("message received: #{message}")
+      messages.push(message)
+    end
+    tcp = Networking::TCPServer.new(Params['testing_server_port'], receive_msg_proc)
+
+    all_threads << tcp.tcp_thread
+
+    while(true) do
+      msg_type, validation_timestamp = messages.pop
+      if msg_type == :GET_INDEX
+        cur_index = ContentData::ContentData.new
+        cur_index.from_file(Params['local_content_data_path'])
+        tcp.send_obj([:PUT_INDEX, validation_timestamp, cur_index])
+        $log4r.info "PUT_INDEX sent with timestamp #{validation_timestamp}"
+        is_index_ok = cur_index.validate
+        tcp.send_obj([:PUT_VALIDATION, validation_timestamp, is_index_ok])
+        $log4r.info "PUT_VALIDATION sent with timestamp #{validation_timestamp}"
+      end
+    end
+  end
+  module_function :run_content_testing_server
+
+  def run_backup_testing_server
+    Log.info('Testing server started')
+    init_log4r
+    $log4r.info 'Testing server started'
+    all_threads = [];
+    messages = Queue.new
+    # used for synchronization between servers
+    validation_timestamp = Time.now.to_i
+    # holds boolean whether all contents according to this timestamp that should be backed are backed and OK
+    is_cur_synch_ok = nil
+    # holds boolean whether all already backuped files are OK
+    is_backup_ok = nil
+    # holds boolean whether master is valid. receive from master
+    is_master_ok = nil
+    # number of contents must be backuped this synch
+    # with current scenarios this number expected to grow
+    # used to check that file_generator is actually running
+    numb_backuped_contents = 0
+
+    all_threads << Thread.new do
+      ContentServer.run_backup_server
+    end
+
+    receive_msg_proc = lambda do |message|
+      $log4r.info("message received: #{message}")
+      messages.push(message)
+    end
+    tcp = Networking::TCPClient.new(Params['content_server_hostname'],
+                                    Params['testing_server_port'], receive_msg_proc)
+    all_threads << tcp.tcp_thread
+
+    # used to request index from master per validation interval of time
+    all_threads << Thread.new do
+      while(true) do
+        sleep Params['validation_interval']
+        validation_timestamp = Time.now.to_i
+        tcp.send_obj([:GET_INDEX, validation_timestamp])
+        $log4r.info "GET_INDEX sent with timestamp #{validation_timestamp}"
+      end
+    end
+
+    # gets messages from master via queue
+    # handles them according to type
+    while(true) do
+      msg_type, response_validation_timestamp, msg_body = messages.pop
+      $log4r.info "#{msg_type} : #{validation_timestamp} : #{msg_body.class}"
+      unless (validation_timestamp == response_validation_timestamp)
+        # TODO problem of servers synch. What should be done here?
+        $log4r.warning "Timestamps differs: requested #{validation_timestamp} : received #{response_validation_timestamp}"
+      end
+
+      case msg_type
+      when :PUT_INDEX
+        # index of already backuped contents
+        backuped_index = ContentData::ContentData.new
+        backuped_index.from_file Params['local_content_data_path']
+        # index contains only master current contents
+        # that must be backuped according to backup_time_requirement parameter
+        index_must_be_backuped = ContentData::ContentData.new(msg_body)
+        # we backup contents, so content mtime used to determine contents should be validated
+        index_must_be_backuped.each_content do |checksum, size, mtime|
+          if (validation_timestamp - mtime < Params['backup_time_requirement'])
+            index_must_be_backuped.remove_content checksum
+          end
+        end
+        is_cur_synch_ok =
+          Validations::IndexValidations.validate_remote_index index_must_be_backuped, backuped_index
+        is_backup_ok = backuped_index.validate
+        numb_backuped_contents = index_must_be_backuped.contents_size
+      when :PUT_VALIDATION
+        is_master_ok = msg_body
+      else
+        $log4r.error "Incorrect message received: #{msg_type}"
+      end
+
+      unless (is_master_ok.nil? || is_cur_synch_ok.nil? || is_backup_ok.nil?)
+        send_email is_master_ok, is_cur_synch_ok, is_backup_ok, numb_backuped_contents
+        is_master_ok = nil
+        is_cur_synch_ok = nil
+        is_backup_ok = nil
+        numb_backuped_contents = 0
+      end
+    end
+  end
+
+
+  def generate_mem_report
+    # Generate memory report
+    current_objects_counters = {}
+    time = Time.now
+    current_objects_counters['Time'] = time.to_i
+    count = ObjectSpace.each_object(String).count
+    current_objects_counters['String'] = count
+    count = ObjectSpace.each_object(ContentData::ContentData).count
+    current_objects_counters['ContentData'] = count
+    dir_count = ObjectSpace.each_object(FileMonitoring::DirStat).count
+    current_objects_counters['DirStat'] = dir_count
+    file_count = ObjectSpace.each_object(FileMonitoring::FileStat).count
+    current_objects_counters['FileStat'] = file_count-dir_count
+
+    # Generate report and update global counters
+    report = ""
+    current_objects_counters.each_key { |type|
+      $objects_counters[type] = 0 unless $objects_counters[type]
+      diff =  current_objects_counters[type] - $objects_counters[type]
+      report += "Type:#{type} raised in:#{diff}   \n"
+      $objects_counters[type] = current_objects_counters[type]
+    }
+    final_report = "Memory report at Time:#{time}:\n#{report}\n"
+    $log4r.info(final_report)
+    final_report
+  end
+  def send_email(is_master_ok, is_cur_synch_ok, is_backup_ok, numb_backuped_contents)
+
+    msg =<<EOF
+Master index ok: #{is_master_ok}
+Backup index ok: #{is_backup_ok}
+Backup includes all master files upto -#{Params['backup_time_requirement']} sec: #{is_cur_synch_ok}
+Number of contents must be back-up: #{numb_backuped_contents}
+#{generate_mem_report}
+EOF
+    Email.send_email(Params['from_email'],
+                     Params['from_email_password'],
+                     Params['to_email'],
+                     'Testing server update',
+                     msg)
+  end
+
+  module_function :send_email, :run_backup_testing_server, :init_log4r, :generate_mem_report
+
+end # module TestingServer
+
+

data/lib/testing_server/version.rb

@@ -0,0 +1,3 @@
+module TestingServer
+  VERSION = "1.1.0"
+end

data/lib/testing_server.rb

@@ -0,0 +1,12 @@
+require 'testing_server/testing_server'
+
+module TestingServer
+  Params.integer('testing_server_port', 4445, 'Remote port to synchronization between testing servers')
+  #Params.integer('email_delay_in_seconds', 60*60*6, 'Number of seconds before sending email again.')
+  Params.integer('validation_interval', 60*60*6, 'Number of seconds between validations')
+  Params.integer('backup_time_requirement', 60*60,
+                 'Max diff in seconds between timestamps of file indexation on master ' +
+                 'and its content indexation on backup.' +
+                 ' NOTE Machines must have time synchronization.' +
+                 ' NOTE This requirement must be set sufficient, i.e. enough to finish copy file process')
+end # module TestingServer

data/lib/validations/index_validations.rb

@@ -0,0 +1,106 @@
+require 'params'
+require 'log'
+require 'content_data'
+require 'file_indexing/index_agent'
+
+# TODO additional params?
+# TODO are params names good enough?
+module Validations
+  class IndexValidations
+
+    # TODO should it be renamed cause it can validate any indexes, not specially remote, one against another.
+
+    # Validates remote index against local file system.
+    # Remote index defined valid when every remote content has at least one valid local instance.
+    #
+    # There are two levels of validation, controlled by instance_check_level system parameter:
+    # * shallow - quick, tests instance for file existence and attributes.
+    # * deep - can take more time, in addition to shallow recalculates hash sum.
+    # For more infoemation see <tt>ContentData</tt> documentation.
+    # @param [ContentData] remote_index it's contents should be validate against local index
+    # @param [ContentData] local_index contains local contents and instances used for validation
+    # @param [Hash] params hash of parameters of validation, can be used to return additional data
+    #
+    #     Supported key/value combinations:
+    #     * key is <tt>:failed</tt> value is <tt>ContentData</tt> used to return failed instances
+    # @return [Boolean] true when every remote content has at least one valid local instance, false otherwise
+    # @raise [ArgumentError] when instance_check_level is incorrect
+    def IndexValidations.validate_remote_index(remote_index, local_index, params = nil)
+      raise ArgumentError 'remote_index must be defined' if remote_index.nil?
+      raise ArgumentError 'local index must be defined' if local_index.nil?
+
+      # used to answer whether specific param was set
+      param_exists = Proc.new do |param|
+        !(params.nil? || params[param].nil?)
+      end
+
+      # used to process method parameters centrally
+      # TODO consider more convenient form of parameters
+      # TODO code duplication with ContentData::validate
+      process_params = Proc.new do |checksum, content_mtime, size, instance_mtime, server, path|
+        if param_exists.call(:failed)
+          params[:failed].add_instance(checksum, size, server, path, instance_mtime)
+        end
+      end
+
+      # result variable
+      is_valid = true
+      # contains contents absent or without valid instances on local system
+      # and corresponding local instances
+      failed = ContentData::ContentData.new
+      # contains checksums of contains absent in local
+      absent_checksums = Array.new
+
+      # contains local instances corresponding to given remote index contents
+      local_index_to_check = ContentData::ContentData.new
+
+      # check whether remote contents exist locally
+      remote_index.each_content do |checksum|
+        unless local_index.content_exists checksum
+          is_valid = false
+          absent_checksums << checksum
+        end
+      end
+
+      # add instances of contents that should be check, i.e. exist in local
+      local_index.each_instance do |checksum, size, content_mtime, instance_mtime, server, path|
+        if remote_index.content_exists checksum
+          local_index_to_check.add_instance checksum, size, server, path, instance_mtime
+        end
+      end
+
+
+      # validate against local file system
+      is_valid = local_index_to_check.validate(:failed => failed) && is_valid
+
+      # contains contents that have at least one valid local instance,
+      # then also corresponding remote content defined valid
+      contents_with_succeeded_instances = ContentData.remove_instances failed, local_index
+
+      # write summary to log
+      # TODO should be controlled from params?
+      absent_checksums.each do |checksum|
+          Log.warning "Content #{checksum} is absent in the local file system"
+      end
+      failed.each_content do |checksum|
+        if !contents_with_succeeded_instances.content_exists checksum
+          # if checked content have no valid local instances
+          # then content defined invalid
+          Log.warning "Content #{checksum} is invalid in the local file system"
+        end
+      end
+
+      # if needed process output params
+      unless params.nil? || params.empty?
+        remote_index.each_instance do |checksum, size, content_mtime, instance_mtime, server, path|
+          unless contents_with_succeeded_instances.content_exists checksum
+            process_params.call checksum, content_mtime, size, instance_mtime, server, path
+          end
+        end
+      end
+
+      is_valid
+    end
+
+  end  # class IndexValidations
+end  # module Validations

data/lib/validations/version.rb

@@ -0,0 +1,3 @@
+module Validations
+  VERSION = "1.1.0"
+end

data/lib/validations.rb

@@ -0,0 +1,4 @@
+require 'validations/index_validations'
+
+module Validations
+end

data/spec/content_data/validations_spec.rb

@@ -0,0 +1,113 @@
+require 'rspec'
+require 'file_indexing/index_agent'
+require 'params'
+require_relative '../../lib/content_data.rb'
+
+module ContentData
+  module Spec
+    describe 'Index validation' do
+      before :all do
+        @size = 100
+        @path = '/dir1/dir2/file'
+        @path2 = '/dir3/dir4/file'
+        @mod_time = 123456
+        @checksum = 'abcde987654321'
+        @checksum2 = '987654321abcde'
+        @server = 'server_1'
+      end
+
+      before :each do
+        @index = ContentData.new
+        @index.add_instance @checksum, @size, @server, @path, @mod_time
+        @index.add_instance @checksum2, @size, @server, @path2, @mod_time
+      end
+
+      context 'with shallow check' do
+        before :all do
+          Params['instance_check_level'] = 'shallow'
+        end
+
+        before :each do
+          File.stub(:exists?).and_return(true)
+          File.stub(:size).and_return(@size)
+          File.stub(:mtime).and_return(@mod_time)
+        end
+
+        it 'succeeds when files exist and their attributes the same as in the index' do
+          @index.validate().should be_true
+        end
+
+        it 'fails when there is a file that doesn\'t exist' do
+          File.stub(:exists?).with(@path).and_return(false)
+          @index.validate().should be_false
+        end
+
+        it 'fails when there is a file with size different from indexed' do
+          File.stub(:size).with(@path).and_return(@size + 10)
+          @index.validate().should be_false
+        end
+
+        it 'fails when there is a file with  modification time different from indexed' do
+          modified_mtime = @mod_time + 10
+          File.stub(:mtime).with(@path).and_return(modified_mtime)
+          @index.validate().should be_false
+        end
+      end
+
+      context 'with deep check (shallow check assumed succeeded)' do
+        before :all do
+          Params['instance_check_level'] = 'deep'
+        end
+
+        before :each do
+          FileIndexing::IndexAgent.stub(:get_checksum).with(@path).and_return(@checksum)
+          FileIndexing::IndexAgent.stub(:get_checksum).with(@path2).and_return(@checksum2)
+          @index.stub(:shallow_check).and_return(true)
+        end
+
+        it 'succeeds when for all files checksums are the same as indexed' do
+          @index.validate().should be_true
+        end
+
+        it 'fails when there is a file with checksum different from indexed' do
+          FileIndexing::IndexAgent.stub(:get_checksum).with(@path2).and_return(@checksum2 + 'a')
+          @index.validate().should be_false
+        end
+      end
+
+      context 'validation params' do
+        before :all do
+          Params['instance_check_level'] = 'shallow'
+        end
+
+        before :each do
+          File.stub(:exists?).and_return(true)
+          File.stub(:size).and_return(@size)
+          File.stub(:mtime).and_return(@mod_time)
+        end
+
+        it ':failed param returns index of absent or invalid instances' do
+          # one instance that absent,
+          absent_checksum = '123'
+          absent_path = @path2 + '1'
+          @index.add_instance absent_checksum, @size, @server, absent_path, @mod_time
+          File.stub(:exists?).with(absent_path).and_return(false)
+
+          # another instance with different content was changed
+          File.stub(:mtime).with(@path2).and_return(@mod_time + 10)
+
+          failed = ContentData.new
+          @index.validate(:failed => failed).should be_false
+          # should be two failed contents, with one instance per content
+          failed.contents_size.should eq(2)
+          failed.content_exists(absent_checksum).should be_true
+          failed.content_exists(@checksum2).should be_true
+          failed.checksum_instances_size(absent_checksum).should eq(1)
+          failed.checksum_instances_size(@checksum2).should eq(1)
+          failed.instance_exists(absent_path, @server, absent_checksum).should be_true
+          failed.instance_exists(@path2, @server, @checksum2).should be_true
+        end
+      end
+    end
+  end
+end

data/spec/file_copy/copy_spec.rb

@@ -0,0 +1,54 @@
+require 'rspec'
+
+require_relative '../../lib/file_copy/copy.rb'
+
+module FileCopy
+  module Spec
+
+    describe 'FileCopy::ssh_connect' do
+      it 'should raise error when username not specified' do
+        ENV.stub(:[]).with(any_args()).and_return(nil)
+        expect { FileCopy::ssh_connect(nil, nil, 'a server') }.to raise_error "Undefined username"
+      end
+
+      it 'should raise error when server not specified' do
+        expect { FileCopy::ssh_connect('kuku', nil, nil) }.to raise_error "Undefined server"
+      end
+
+      it 'should try to connect if username is set explicitly' do
+        Net::SSH.should_receive(:start).with(any_args())
+        FileCopy::ssh_connect('kuku', nil, 'a server')
+      end
+      it 'should try to connect if username is set via ENV variable' do
+        Net::SSH.should_receive(:start).with(any_args())
+        ENV.stub(:[]).with("USER").and_return('kuku')
+        FileCopy::ssh_connect(nil, nil, 'a server')
+      end
+    end
+
+    # TODO(kolman): Bad test, should rewrite and understand how to write test correctly.
+    describe 'FileCopy::sftp_copy' do
+      it 'call upload with correct files' do
+        ssh_connection = double('Net::SSH::Connection')
+        sftp_session = double('Net::SFTP::Session')
+        uploader = double('Operations::Upload')
+        sftp_attributes = double('Attributes')
+
+        # Stubbing sftp.
+        FileCopy.stub(:ssh_connect).and_return(ssh_connection)
+        ssh_connection.stub(:sftp).and_return(sftp_session)
+        sftp_session.stub(:connect).and_yield(sftp_session)
+        sftp_session.stub(:stat!).and_return(sftp_attributes)
+        sftp_attributes.stub(:directory?).and_return(true)
+        uploader.stub(:wait).and_return(true, true)
+
+        # Test file uploaded
+        sftp_session.should_receive(:upload).with('a', 'b').and_return(uploader)
+        sftp_session.should_receive(:upload).with('c', 'd').and_return(uploader)
+        FileCopy::sftp_copy(nil, nil, nil, { 'a' => 'b', 'c' => 'd' })
+      end
+    end
+
+  end
+end
+

data/spec/file_indexing/index_agent_spec.rb

@@ -0,0 +1,53 @@
+require 'rspec'
+require 'tempfile'
+
+require_relative '../../lib/file_indexing/index_agent.rb'
+
+module FileCopy
+  module Spec
+
+    describe 'checksum' do
+      it 'should generate correct checksum' do
+        # The test does not checks the problem the problem is when reading from File
+        # class which handles read(num) different from read()
+        content = ''
+        100000.times { content << 'abagadavazahatikalamansapazkareshet' }
+        content_checksum = FileIndexing::IndexAgent.get_content_checksum(content)
+
+        stream = StringIO.new(content)
+        File.stub(:open).and_yield(stream)
+        file_checksum = FileIndexing::IndexAgent.get_checksum('kuku')
+
+        content_checksum.should == file_checksum
+        content_checksum.should == '381e99eb0e2dfcaf45c9a367a04a4197ef3039a6'
+      end
+
+      it 'should generate correct checksum for temp file' do
+        # A hack to get tmp file name
+        tmp_file = Tempfile.new('foo')
+        path = tmp_file .path
+        tmp_file .close()
+
+        # Open file in binary mode.
+        file = File.open(path, 'wb')
+        100000.times { file.write('abagadavazahatikalamansapazkareshet') }
+        file.close()
+
+        file_checksum = FileIndexing::IndexAgent.get_checksum(path)
+        file_checksum.should == '381e99eb0e2dfcaf45c9a367a04a4197ef3039a6'
+
+        File.open(path, 'rb') { |f|
+          content = f.read()
+          content_checksum = FileIndexing::IndexAgent.get_content_checksum(content)
+          content_checksum.should == '381e99eb0e2dfcaf45c9a367a04a4197ef3039a6'
+          file_checksum.should == content_checksum
+        }
+
+        # Delete tmp file.
+        tmp_file.unlink
+      end
+
+    end
+  end
+end
+

data/spec/networking/tcp_spec.rb

@@ -0,0 +1,95 @@
+require 'log'
+require 'rspec'
+require 'socket'
+require 'stringio'
+
+require_relative '../../lib/networking/tcp'
+
+# Uncomment to debug spec.
+Params['log_write_to_console'] = true
+Params['log_debug_level'] = 0
+Log.init
+
+module Networking
+  module Spec
+
+    describe 'TCPClient' do
+      it 'should warn when destination host+port are bad' do
+        data = 'kuku!!!'
+        stream = StringIO.new
+        stream.close()
+        ::TCPSocket.stub(:new).and_return(stream)
+        Log.should_receive(:warning).with('Socket not opened for writing, skipping send.')
+
+        # Send data first.
+        tcp_client = TCPClient.new('kuku', 5555)
+        # Send has to fail.
+        tcp_client.send_obj(data).should be(false)
+      end
+
+      it 'should send data and server should receive callback function' do
+        info = 'info'
+        data = 'kuku!!!'
+        stream = StringIO.new
+        ::Socket.stub(:tcp_server_loop).and_yield(stream, info)
+        ::TCPSocket.stub(:new).and_return(stream)
+
+        # Send data first.
+        tcp_client = TCPClient.new('kuku', 5555)
+        # Send has to be successful.
+        tcp_client.send_obj(data).should be(21)
+
+        # Note this is very important so that reading the stream from beginning.
+        stream.rewind
+
+        func = lambda { |info, data| Log.info("info, data: #{info}, #{data}") }
+        # Check data is received.
+        func.should_receive(:call).with(info, data)
+
+        tcp_server = TCPServer.new(5555, func)
+        # Wait on server thread.
+        tcp_server.tcp_thread.join
+      end
+
+      # TODO(kolman): Don't work, missing client send_obj/open_socket execution in
+      # the correct place.
+      it 'should connect and receive callback from server' do
+        info = 'info'
+        data = 'kuku!!!'
+        stream = StringIO.new
+        ::Socket.stub(:tcp_server_loop).once.and_yield(stream, info)
+        ::TCPSocket.stub(:new).and_return(stream)
+
+        tcp_server = nil
+        new_clb = lambda { |i|
+          Log.info("#2 - After after @sockets is filled. Send has to be successful.")
+          tcp_server.send_obj(data).should eq({info => 21})
+
+          stream.rewind
+
+          func = lambda { |d|
+            Log.info("#6, After client initialized, it should send object.")
+            Log.info("data: #{d}")
+            # Validate received data.
+            d.should eq(data)
+            # Exit tcp client reading loop thread.
+            Thread.exit
+          }
+
+          Log.info("#4 - Create client and wait for read data.")
+          tcp_client = TCPClient.new('kuku', 5555, func)
+          tcp_client.tcp_thread.abort_on_exception = true
+          tcp_client.tcp_thread.join()
+          # We can finish now. Exit tcp server listening loop.
+          Thread.exit
+        }
+
+        Log.info("#1 - Create server, send data and wait.")
+        tcp_server = TCPServer.new(5555, nil, new_clb)
+        tcp_server.tcp_thread.abort_on_exception = true
+        tcp_server.tcp_thread.join()
+      end
+    end
+  end
+end
+