content_server 0.0.10 → 1.0.0

data/lib/content_server/queue_copy.rb

@@ -5,199 +5,207 @@ require 'file_indexing/index_agent'
 require 'log'
 require 'networking/tcp'
 
-module BBFS
-  module ContentServer
-    Params.integer('ack_timeout', 5, 'Timeout of ack from backup server in seconds.')
-
-    # Copy message types.
-    :ACK_MESSAGE
-    :COPY_MESSAGE
-    :SEND_COPY_MESSAGE
-    :COPY_CHUNK
-    :COPY_CHUNK_FROM_REMOTE
-    :ABORT_COPY # Asks the sender to abort file copy.
-    :RESET_RESUME_COPY # Sends the stream sender to resend chunk or resume from different offset.
-
-    # Simple copier, gets inputs events (files to copy), requests ack from backup to copy
-    # then copies one file.
-    class FileCopyServer
-      def initialize(copy_input_queue, port)
-        # Local simple tcp connection.
-        @backup_tcp = Networking::TCPServer.new(port, method(:receive_message))
-        @copy_input_queue = copy_input_queue
-        # Stores for each checksum, the file source path.
-        # TODO(kolman): If there are items in copy_prepare which timeout (don't get ack),
-        # resend the ack request.
-        @copy_prepare = {}
-        @file_streamer = FileStreamer.new(method(:send_chunk))
-      end
-
-      def send_chunk(*arg)
-        @copy_input_queue.push([:COPY_CHUNK, arg])
-      end
 
-      def receive_message(addr_info, message)
-        # Add ack message to copy queue.
-        Log.info("message received: #{message}")
-        @copy_input_queue.push(message)
-      end
+module ContentServer
+  Params.integer('ack_timeout', 5, 'Timeout of ack from backup server in seconds.')
+
+  # Copy message types.
+  :ACK_MESSAGE
+  :COPY_MESSAGE
+  :SEND_COPY_MESSAGE
+  :COPY_CHUNK
+  :COPY_CHUNK_FROM_REMOTE
+  :ABORT_COPY # Asks the sender to abort file copy.
+  :RESET_RESUME_COPY # Sends the stream sender to resend chunk or resume from different offset.
+
+  # Simple copier, gets inputs events (files to copy), requests ack from backup to copy
+  # then copies one file.
+  class FileCopyServer
+    def initialize(copy_input_queue, port)
+      # Local simple tcp connection.
+      @backup_tcp = Networking::TCPServer.new(port, method(:receive_message))
+      @copy_input_queue = copy_input_queue
+      # Stores for each checksum, the file source path.
+      # TODO(kolman): If there are items in copy_prepare which timeout (don't get ack),
+      # resend the ack request.
+      @copy_prepare = {}
+      @file_streamer = FileStreamer.new(method(:send_chunk))
+      Log.debug2("initialize FileCopyServer on port:#{port}")
+    end
+
+    def send_chunk(*arg)
+      @copy_input_queue.push([:COPY_CHUNK, arg])
+    end
+
+    def receive_message(addr_info, message)
+      # Add ack message to copy queue.
+      Log.info("Master Copy Server message received: #{message}")
+      @copy_input_queue.push(message)
+    end
+
+    def run()
+      threads = []
+      threads << @backup_tcp.tcp_thread if @backup_tcp != nil
+      threads << Thread.new do
+        while true do
+          Log.info 'Waiting on copy files events.'
+          message_type, message_content = @copy_input_queue.pop
+
+          if message_type == :COPY_MESSAGE
+            Log.info "Copy file event: #{message_content}"
+            # Prepare source,dest map for copy.
+            message_content.instances.each { |key, instance|
+              # If not already sending.
+              if !@copy_prepare.key?(instance.checksum) || !@copy_prepare[instance.checksum][1]
+                @copy_prepare[instance.checksum] = [instance.full_path, false]
+                Log.info("Sending ack for: #{instance.checksum}")
+                @backup_tcp.send_obj([:ACK_MESSAGE, [instance.checksum, Time.now.to_i]])
+              end
+            }
+          elsif message_type == :ACK_MESSAGE
+            # Received ack from backup, copy file if all is good.
+            # The timestamp is of local content server! not backup server!
+            timestamp, ack, checksum = message_content
 
-      def run()
-        threads = []
-        threads << @backup_tcp.tcp_thread if @backup_tcp != nil
-        threads << Thread.new do
-          while true do
-            Log.info 'Waiting on copy files events.'
-            message_type, message_content = @copy_input_queue.pop
-
-            if message_type == :COPY_MESSAGE
-              Log.info "Copy file event: #{message_content}"
-              # Prepare source,dest map for copy.
-              message_content.instances.each { |key, instance|
-                # If not already sending.
-                if !@copy_prepare.key?(instance.checksum) || !@copy_prepare[instance.checksum][1]
-                  @copy_prepare[instance.checksum] = [instance.full_path, false]
-                  Log.info("Sending ack for: #{instance.checksum}")
-                  @backup_tcp.send_obj([:ACK_MESSAGE, [instance.checksum, Time.now.to_i]])
-                end
-              }
-            elsif message_type == :ACK_MESSAGE
-              # Received ack from backup, copy file if all is good.
-              # The timestamp is of local content server! not backup server!
-              timestamp, ack, checksum = message_content
-
-              Log.info("Ack (#{ack}) received for: #{checksum}, timestamp: #{timestamp} " \
+            Log.info("Ack (#{ack}) received for: #{checksum}, timestamp: #{timestamp} " \
                        "now: #{Time.now.to_i}")
 
-              # Copy file if ack (does not exists on backup and not too much time passed)
-              if ack && (Time.now.to_i - timestamp < Params['ack_timeout'])
-                if !@copy_prepare.key?(checksum) || @copy_prepare[checksum][1]
-                  Log.warning("File was aborted, copied, or started copy just now: #{checksum}")
-                else
-                  path = @copy_prepare[checksum][0]
-                  Log.info "Streaming file: #{checksum} #{path}."
-                  @file_streamer.start_streaming(checksum, path)
-                  # Ack received, setting prepare to true
-                  @copy_prepare[checksum][1] = true
-                end
+            # Copy file if ack (does not exists on backup and not too much time passed)
+            if ack && (Time.now.to_i - timestamp < Params['ack_timeout'])
+              if !@copy_prepare.key?(checksum) || @copy_prepare[checksum][1]
+                Log.warning("File was aborted, copied, or started copy just now: #{checksum}")
               else
-                Log.debug1("Ack timed out span: #{Time.now.to_i - timestamp} > " \
-                           "timeout: #{Params['ack_timeout']}")
-              end
-            elsif message_type == :COPY_CHUNK_FROM_REMOTE
-              checksum = message_content
-              @file_streamer.copy_another_chuck(checksum)
-            elsif message_type == :COPY_CHUNK
-              # We open the message here for printing info and deleting copy_prepare!
-              file_checksum, offset, file_size, content, content_checksum = message_content
-              Log.info("Send chunk for file #{file_checksum}, offset: #{offset} " \
-                       "filesize: #{file_size}.")
-              # Blocking send.
-              @backup_tcp.send_obj([:COPY_CHUNK, message_content])
-              if content.nil? and content_checksum.nil?
-                @copy_prepare.delete(file_checksum)
+                path = @copy_prepare[checksum][0]
+                Log.info "Streaming file: #{checksum} #{path}."
+                @file_streamer.start_streaming(checksum, path)
+                # Ack received, setting prepare to true
+                @copy_prepare[checksum][1] = true
               end
-            elsif message_type == :ABORT_COPY
-              Log.info("Aborting file copy: #{message_content}")
-              if @copy_prepare.key?(message_content)
-                Log.info("Aborting: #{@copy_prepare[message_content][0]}")
-                @copy_prepare.delete(message_content)
-              end
-              @file_streamer.abort_streaming(message_content)
-            elsif message_type == :RESET_RESUME_COPY
-              file_checksum, new_offset = message_content
-              Log.info("Resetting/Resuming file (#{file_checksum}) copy to #{new_offset}")
-              @file_streamer.reset_streaming(file_checksum, new_offset)
             else
-              Log.error("Copy event not supported: #{message_type}")
-            end # handle messages here
-          end
-          Log.error("Should not reach here, loop should continue.")
+              Log.debug1("Ack timed out span: #{Time.now.to_i - timestamp} > " \
+                           "timeout: #{Params['ack_timeout']}")
+            end
+          elsif message_type == :COPY_CHUNK_FROM_REMOTE
+            checksum = message_content
+            @file_streamer.copy_another_chuck(checksum)
+          elsif message_type == :COPY_CHUNK
+            # We open the message here for printing info and deleting copy_prepare!
+            file_checksum, offset, file_size, content, content_checksum = message_content
+            Log.debug1("Send chunk for file #{file_checksum}, offset: #{offset} " \
+                         "filesize: #{file_size}.")
+            # Blocking send.
+            @backup_tcp.send_obj([:COPY_CHUNK, message_content])
+            if content.nil? and content_checksum.nil?
+              @copy_prepare.delete(file_checksum)
+            end
+          elsif message_type == :ABORT_COPY
+            Log.info("Aborting file copy: #{message_content}")
+            if @copy_prepare.key?(message_content)
+              Log.info("Aborting: #{@copy_prepare[message_content][0]}")
+              @copy_prepare.delete(message_content)
+            end
+            @file_streamer.abort_streaming(message_content)
+          elsif message_type == :RESET_RESUME_COPY
+            file_checksum, new_offset = message_content
+            Log.info("Resetting/Resuming file (#{file_checksum}) copy to #{new_offset}")
+            @file_streamer.reset_streaming(file_checksum, new_offset)
+          else
+            Log.error("Copy event not supported: #{message_type}")
+          end # handle messages here
         end
+        Log.error("Should not reach here, loop should continue.")
       end
-    end  # class QueueCopy
-
-    class FileCopyClient
-      def initialize(host, port, dynamic_content_data)
-        @local_queue = Queue.new
-        @dynamic_content_data = dynamic_content_data
-        @tcp_server = Networking::TCPClient.new(host, port, method(:handle_message))
-        @file_receiver = FileReceiver.new(method(:done_copy),
-                                          method(:abort_copy),
-                                          method(:reset_copy))
-        @local_thread = Thread.new do
-          loop do
-            handle(@local_queue.pop)
-          end
+    end
+  end  # class QueueCopy
+
+  class FileCopyClient
+    def initialize(host, port, dynamic_content_data, process_variables)
+      @local_queue = Queue.new
+      @dynamic_content_data = dynamic_content_data
+      @tcp_client = Networking::TCPClient.new(host, port, method(:handle_message))
+      @file_receiver = FileReceiver.new(method(:done_copy),
+                                        method(:abort_copy),
+                                        method(:reset_copy))
+      @local_thread = Thread.new do
+        loop do
+          handle(@local_queue.pop)
         end
-        @local_thread.abort_on_exception = true
-      end
-
-      def threads
-        ret = [@local_thread]
-        ret << @tcp_server.tcp_thread if @tcp_server != nil
-        return ret
-      end
-
-      def request_copy(content_data)
-        handle_message([:SEND_COPY_MESSAGE, content_data])
       end
-
-      def abort_copy(checksum)
-        handle_message([:ABORT_COPY, checksum])
-      end
-
-      def reset_copy(checksum, new_offset)
-        handle_message([:RESET_RESUME_COPY, [checksum, new_offset]])
-      end
-
-      def done_copy(local_file_checksum, local_path)
-        Log.info("Done copy file: #{local_path}, #{local_file_checksum}")
-      end
-
-      def handle_message(message)
-        Log.debug2('QueueFileReceiver handle message')
-        @local_queue.push(message)
-      end
-
-      # This is a function which receives the messages (file or ack) and return answer in case
-      # of ack. Note that it is being executed from the class thread only!
-      def handle(message)
-        message_type, message_content = message
-        if message_type == :SEND_COPY_MESSAGE
-          Log.debug1("Requesting file (content data) to copy.")
-          Log.debug3("File requested: #{message_content.to_s}")
-          bytes_written = @tcp_server.send_obj([:COPY_MESSAGE, message_content])
-          Log.debug1("Sending copy message succeeded? bytes_written: #{bytes_written}.")
-        elsif message_type == :COPY_CHUNK
-          Log.debug1('Chunk received.')
-          if @file_receiver.receive_chunk(*message_content)
-            file_checksum, offset, file_size, content, content_checksum = message_content
-            @tcp_server.send_obj([:COPY_CHUNK_FROM_REMOTE, file_checksum])
-          end
-        elsif message_type == :ACK_MESSAGE
-          checksum, timestamp = message_content
-          # Here we should check file existence
-          Log.debug1("Returning ack for: #{checksum}, timestamp: #{timestamp}")
-          Log.debug1("Ack: #{!@dynamic_content_data.exists?(checksum)}")
-          @tcp_server.send_obj([:ACK_MESSAGE, [timestamp,
-                                               !@dynamic_content_data.exists?(checksum),
-                                               checksum]])
-        elsif message_type == :ABORT_COPY
-          @tcp_server.send_obj([:ABORT_COPY, message_content])
-        elsif message_type == :RESET_RESUME_COPY
-          @tcp_server.send_obj([:RESET_RESUME_COPY, message_content])
-        else
-          Log.error("Unexpected message type: #{message_type}")
+      @local_thread.abort_on_exception = true
+      @process_variables = process_variables
+      Log.debug2("initialize FileCopyClient  host:#{host}  port:#{port}")
+    end
+
+    def threads
+      ret = [@local_thread]
+      ret << @tcp_client.tcp_thread if @tcp_client != nil
+      return ret
+    end
+
+    def request_copy(content_data)
+      handle_message([:SEND_COPY_MESSAGE, content_data])
+    end
+
+    def abort_copy(checksum)
+      handle_message([:ABORT_COPY, checksum])
+    end
+
+    def reset_copy(checksum, new_offset)
+      handle_message([:RESET_RESUME_COPY, [checksum, new_offset]])
+    end
+
+    def done_copy(local_file_checksum, local_path)
+      add_process_variables_info()
+      Log.info("Done copy file: #{local_path}, #{local_file_checksum}")
+    end
+
+    def add_process_variables_info()
+      @process_variables.inc('num_files_received')
+    end
+
+    def handle_message(message)
+      Log.debug2('QueueFileReceiver handle message')
+      @local_queue.push(message)
+    end
+
+    # This is a function which receives the messages (file or ack) and return answer in case
+    # of ack. Note that it is being executed from the class thread only!
+    def handle(message)
+      message_type, message_content = message
+      if message_type == :SEND_COPY_MESSAGE
+        Log.debug1("Requesting file (content data) to copy.")
+        Log.debug3("File requested: #{message_content.to_s}")
+        bytes_written = @tcp_client.send_obj([:COPY_MESSAGE, message_content])
+        Log.debug1("Sending copy message succeeded? bytes_written: #{bytes_written}.")
+      elsif message_type == :COPY_CHUNK
+        Log.debug1('Chunk received.')
+        if @file_receiver.receive_chunk(*message_content)
+          file_checksum, offset, file_size, content, content_checksum = message_content
+          @tcp_client.send_obj([:COPY_CHUNK_FROM_REMOTE, file_checksum])
         end
+      elsif message_type == :ACK_MESSAGE
+        checksum, timestamp = message_content
+        # Here we should check file existence
+        Log.debug1("Returning ack for: #{checksum}, timestamp: #{timestamp}")
+        Log.debug1("Ack: #{!@dynamic_content_data.exists?(checksum)}")
+        @tcp_client.send_obj([:ACK_MESSAGE, [timestamp,
+                                             !@dynamic_content_data.exists?(checksum),
+                                             checksum]])
+      elsif message_type == :ABORT_COPY
+        @tcp_client.send_obj([:ABORT_COPY, message_content])
+      elsif message_type == :RESET_RESUME_COPY
+        @tcp_client.send_obj([:RESET_RESUME_COPY, message_content])
+      else
+        Log.error("Unexpected message type: #{message_type}")
       end
-
-      # Creates destination filename for backup server, input is base folder and sha1.
-      # for example: folder:/mnt/hd1/bbbackup, sha1:d0be2dc421be4fcd0172e5afceea3970e2f3d940
-      # dest filename: /mnt/hd1/bbbackup/d0/be/2d/d0be2dc421be4fcd0172e5afceea3970e2f3d940
-      def self.destination_filename(folder, sha1)
-        File.join(folder, sha1[0,2], sha1[2,2], sha1)
-      end
-    end # class QueueFileReceiver
-  end
+    end
+
+    # Creates destination filename for backup server, input is base folder and sha1.
+    # for example: folder:/mnt/hd1/bbbackup, sha1:d0be2dc421be4fcd0172e5afceea3970e2f3d940
+    # dest filename: /mnt/hd1/bbbackup/d0/be/2d/d0be2dc421be4fcd0172e5afceea3970e2f3d940
+    def self.destination_filename(folder, sha1)
+      File.join(folder, sha1[0,2], sha1[2,2], sha1)
+    end
+  end # class QueueFileReceiver
 end
+

data/lib/content_server/queue_indexer.rb

@@ -2,109 +2,108 @@ require 'file_indexing/index_agent'
 require 'file_indexing/indexer_patterns'
 require 'log'
 
-module BBFS
-  module ContentServer
+module ContentServer
 
-    # Simple indexer, gets inputs events (files to index) and outputs
-    # content data updates into output queue.
-    class QueueIndexer
+  # Simple indexer, gets inputs events (files to index) and outputs
+  # content data updates into output queue.
+  class QueueIndexer
 
-      def initialize(input_queue, output_queue, content_data_path)
-        @input_queue = input_queue
-        @output_queue = output_queue
-        @content_data_path = content_data_path
-      end
+    def initialize(input_queue, output_queue, content_data_path)
+      @input_queue = input_queue
+      @output_queue = output_queue
+      @content_data_path = content_data_path
+    end
 
-      def run
-        server_content_data = ContentData::ContentData.new
-        # Shallow check content data files.
-        tmp_content_data = ContentData::ContentData.new
-        tmp_content_data.from_file(@content_data_path) if File.exists?(@content_data_path)
-        tmp_content_data.instances.each_value do |instance|
-          # Skipp instances (files) which did not pass the shallow check.
-          Log.info('Shallow checking content data:')
-          if shallow_check(instance)
-            Log.info("exists: #{instance.full_path}")
-            server_content_data.add_content(tmp_content_data.contents[instance.checksum])
-            server_content_data.add_instance(instance)
-          else
-            Log.info("changed: #{instance.full_path}")
-            # Add non existing and changed files to index queue.
-            @input_queue.push([FileMonitoring::FileStatEnum::STABLE, instance.full_path])
-          end
+    def run
+      server_content_data = ContentData::ContentData.new
+      # Shallow check content data files.
+      tmp_content_data = ContentData::ContentData.new
+      tmp_content_data.from_file(@content_data_path) if File.exists?(@content_data_path)
+      tmp_content_data.instances.each_value do |instance|
+        # Skipp instances (files) which did not pass the shallow check.
+        Log.info('Shallow checking content data:')
+        if shallow_check(instance)
+          Log.info("exists: #{instance.full_path}")
+          server_content_data.add_content(tmp_content_data.contents[instance.checksum])
+          server_content_data.add_instance(instance)
+        else
+          Log.info("changed: #{instance.full_path}")
+          # Add non existing and changed files to index queue.
+          @input_queue.push([FileMonitoring::FileStatEnum::STABLE, instance.full_path])
         end
+      end
 
-        # Start indexing on demand and write changes to queue
-        thread = Thread.new do
-          while true do
-            Log.info 'Waiting on index input queue.'
-            state, is_dir, path = @input_queue.pop
-            Log.info "event: #{state}, #{is_dir}, #{path}."
+      # Start indexing on demand and write changes to queue
+      thread = Thread.new do
+        while true do
+          Log.info 'Waiting on index input queue.'
+          state, is_dir, path = @input_queue.pop
+          Log.info "event: #{state}, #{is_dir}, #{path}."
 
-            # index files and add to copy queue
-            # delete directory with it's sub files
-            # delete file
-            if state == FileMonitoring::FileStatEnum::STABLE && !is_dir
-              Log.info "Indexing content #{path}."
-              index_agent = FileIndexing::IndexAgent.new
-              indexer_patterns = FileIndexing::IndexerPatterns.new
-              indexer_patterns.add_pattern(path)
-              index_agent.index(indexer_patterns, server_content_data)
-              Log.info("Failed files: #{index_agent.failed_files.to_a.join(',')}.") \
+          # index files and add to copy queue
+          # delete directory with it's sub files
+          # delete file
+          if state == FileMonitoring::FileStatEnum::STABLE && !is_dir
+            Log.info "Indexing content #{path}."
+            index_agent = FileIndexing::IndexAgent.new
+            indexer_patterns = FileIndexing::IndexerPatterns.new
+            indexer_patterns.add_pattern(path)
+            index_agent.index(indexer_patterns, server_content_data)
+            Log.info("Failed files: #{index_agent.failed_files.to_a.join(',')}.") \
                   if !index_agent.failed_files.empty?
-              Log.info("indexed content #{index_agent.indexed_content}.")
-              server_content_data.merge index_agent.indexed_content
-            elsif ((state == FileMonitoring::FileStatEnum::NON_EXISTING ||
+            Log.info("indexed content #{index_agent.indexed_content}.")
+            server_content_data.merge index_agent.indexed_content
+          elsif ((state == FileMonitoring::FileStatEnum::NON_EXISTING ||
               state == FileMonitoring::FileStatEnum::CHANGED) && !is_dir)
-              # If file content changed, we should remove old instance.
-              key = FileIndexing::IndexAgent.global_path(path)
-              # Check if deleted file exists at content data.
-              Log.info("Instance to remove: #{key}")
-              if server_content_data.instances.key?(key)
-                instance_to_remove = server_content_data.instances[key]
-                # Remove file from content data only if it does not pass the shallow check, i.e.,
-                # content has changed/removed.
-                if !shallow_check(instance_to_remove)
-                  content_to_remove = server_content_data.contents[instance_to_remove.checksum]
-                  # Remove the deleted instance.
-                  content_data_to_remove = ContentData::ContentData.new
-                  content_data_to_remove.add_content(content_to_remove)
-                  content_data_to_remove.add_instance(instance_to_remove)
-                  # Remove the file.
-                  server_content_data = ContentData::ContentData.remove_instances(
-                      content_data_to_remove, server_content_data)
-                end
+            # If file content changed, we should remove old instance.
+            key = FileIndexing::IndexAgent.global_path(path)
+            # Check if deleted file exists at content data.
+            Log.info("Instance to remove: #{key}")
+            if server_content_data.instances.key?(key)
+              instance_to_remove = server_content_data.instances[key]
+              # Remove file from content data only if it does not pass the shallow check, i.e.,
+              # content has changed/removed.
+              if !shallow_check(instance_to_remove)
+                content_to_remove = server_content_data.contents[instance_to_remove.checksum]
+                # Remove the deleted instance.
+                content_data_to_remove = ContentData::ContentData.new
+                content_data_to_remove.add_content(content_to_remove)
+                content_data_to_remove.add_instance(instance_to_remove)
+                # Remove the file.
+                server_content_data = ContentData::ContentData.remove_instances(
+                    content_data_to_remove, server_content_data)
               end
-            elsif state == FileMonitoring::FileStatEnum::NON_EXISTING && is_dir
-              Log.info("NonExisting/Changed: #{path}")
-              # Remove directory but only when non-existing.
-              Log.info("Directory to remove: #{path}")
-              global_dir = FileIndexing::IndexAgent.global_path(path)
-              server_content_data = ContentData::ContentData.remove_directory(
-              server_content_data, global_dir)
-            else
-              Log.info("This case should not be handled: #{state}, #{is_dir}, #{path}.")
             end
-            # TODO(kolman): Don't write to file each change?
-            Log.info "Writing server content data to #{@content_data_path}."
-            server_content_data.to_file(@content_data_path)
+          elsif state == FileMonitoring::FileStatEnum::NON_EXISTING && is_dir
+            Log.info("NonExisting/Changed: #{path}")
+            # Remove directory but only when non-existing.
+            Log.info("Directory to remove: #{path}")
+            global_dir = FileIndexing::IndexAgent.global_path(path)
+            server_content_data = ContentData::ContentData.remove_directory(
+                server_content_data, global_dir)
+          else
+            Log.info("This case should not be handled: #{state}, #{is_dir}, #{path}.")
+          end
+          # TODO(kolman): Don't write to file each change?
+          Log.info "Writing server content data to #{@content_data_path}."
+          server_content_data.to_file(@content_data_path)
 
-            Log.info 'Adding server content data to queue.'
-            @output_queue.push(ContentData::ContentData.new(server_content_data))
-          end  # while true do
-        end  # Thread.new do
-        thread
-      end  # def run
+          Log.info 'Adding server content data to queue.'
+          @output_queue.push(ContentData::ContentData.new(server_content_data))
+        end  # while true do
+      end  # Thread.new do
+      thread
+    end  # def run
 
-      # Check file existence, check it's size and modification date.
-      # If something wrong reindex the file and update content data.
-      def shallow_check(instance)
-        shallow_instance = FileIndexing::IndexAgent.create_shallow_instance(instance.full_path)
-        return false unless shallow_instance
-        return (shallow_instance.size == instance.size &&
-                shallow_instance.modification_time == instance.modification_time)
-      end
+    # Check file existence, check it's size and modification date.
+    # If something wrong reindex the file and update content data.
+    def shallow_check(instance)
+      shallow_instance = FileIndexing::IndexAgent.create_shallow_instance(instance.full_path)
+      return false unless shallow_instance
+      return (shallow_instance.size == instance.size &&
+          shallow_instance.modification_time == instance.modification_time)
+    end
 
-    end  # class QueueIndexer
-  end
+  end  # class QueueIndexer
 end
+