content_server 1.0.3 → 1.1.0

data/bin/backup_server

@@ -25,12 +25,23 @@ rescue SystemExit, SignalException => exc
   # TODO (genadyp) do we need to trap signals by types?
   puts("Interrupt or Exit happened in #{Params['service_name']} server: #{exc.class}, " +
                 "stopping process.\nBacktrace:\n#{exc.backtrace.join("\n")}")
+  puts("Force writing local content data to #{Params['local_content_data_path']}.")
+  ContentServer::local_dynamic_content_data.last_content_data.to_file(ContentServer::tmp_content_data_file)
+  sleep(0.1)  # Added to prevent mv access issue
+  ::FileUtils.mv(ContentServer::tmp_content_data_file, Params['local_content_data_path'])
+
+
   Log.error("Interrupt or Exit happened in #{Params['service_name']} server: #{exc.class}, " +
             "stopping process.\nBacktrace:\n#{exc.backtrace.join("\n")}")
   Log.flush
   exit
 rescue Exception => exc
   puts("Exception happened in #{Params['service_name']} server: #{exc.class}:#{exc.message}\nBacktrace:\n#{exc.backtrace.join("\n")}")
+  puts("Force writing local content data to #{Params['local_content_data_path']}.")
+  ContentServer::local_dynamic_content_data.last_content_data.to_file(ContentServer::tmp_content_data_file)
+  sleep(0.1)  # Added to prevent mv access issue
+  ::FileUtils.mv(ContentServer::tmp_content_data_file, Params['local_content_data_path'])
+
   Log.error("Exception happened in #{Params['service_name']} server: #{exc.class}:#{exc.message}\nBacktrace:\n#{exc.backtrace.join("\n")}")
   if retries > 0
     Log.debug1("Restarting (retries:#{retries}).")

data/bin/content_server

@@ -20,14 +20,25 @@ begin
   RunInBackground.run { ContentServer.run_content_server }
 rescue SystemExit, SignalException => exc
   # TODO (genadyp) do we need to trap signals by types?
+  #force dump of content data to file
   puts("Interrupt or Exit happened in #{Params['service_name']} server: #{exc.class}, " +
            "stopping process.\nBacktrace:\n#{exc.backtrace.join("\n")}")
+  puts("Force writing local content data to #{Params['local_content_data_path']}.")
+  ContentServer::local_dynamic_content_data.last_content_data.to_file(ContentServer::tmp_content_data_file)
+  sleep(0.1)  # Added to prevent mv access issue
+  ::FileUtils.mv(ContentServer::tmp_content_data_file, Params['local_content_data_path'])
+
   Log.error("Interrupt or Exit happened in #{Params['service_name']} server: #{exc.class}, " +
             "stopping process.\nBacktrace:\n#{exc.backtrace.join("\n")}")
   Log.flush
   exit
 rescue Exception => exc
   puts("Exception happened in #{Params['service_name']} server: #{exc.class}:#{exc.message}\nBacktrace:\n#{exc.backtrace.join("\n")}")
+  puts("Force writing local content data to #{Params['local_content_data_path']}.")
+  ContentServer::local_dynamic_content_data.last_content_data.to_file(ContentServer::tmp_content_data_file)
+  sleep(0.1)  # Added to prevent mv access issue
+  ::FileUtils.mv(ContentServer::tmp_content_data_file, Params['local_content_data_path'])
+
   Log.error("Exception happened in #{Params['service_name']} server: #{exc.class}:#{exc.message}\nBacktrace:\n#{exc.backtrace.join("\n")}")
   if retries > 0
     Log.debug1("Restarting (retries:#{retries}).")

data/lib/content_server.rb

@@ -7,8 +7,7 @@ module ContentServer
 
   # Monitoring
   Params.boolean('enable_monitoring', false, 'Whether to enable process monitoring or not.')
-  Params.global('process_vars', nil, 'container of process variables reflected to http')
-  Params.integer('process_vars_delay', 10, 'pulling time of variables')
+  Params.integer('process_vars_delay', 3, 'pulling time of variables')
 
   # Handling thread exceptions.
   Params.boolean('abort_on_exception', true, 'Any exception in any thread will abort the run.')

data/lib/content_server/backup_server.rb

@@ -9,10 +9,10 @@ require 'content_server/queue_copy'
 require 'content_server/remote_content'
 require 'file_indexing'
 require 'file_monitoring'
+require 'content_server/globals'
 require 'log'
 require 'networking/tcp'
 require 'params'
-require 'process_monitoring/thread_safe_hash'
 require 'process_monitoring/monitoring'
 require 'process_monitoring/monitoring_info'
 
@@ -23,8 +23,18 @@ module ContentServer
   Params.string('content_server_hostname', nil, 'IP or DNS of backup server.')
   Params.integer('content_server_data_port', 3333, 'Port to copy content data from.')
   Params.integer('content_server_files_port', 4444, 'Listening port in backup server for files')
-
   Params.integer('backup_check_delay', 5, 'Delay in seconds between two content vs backup checks.')
+  Params.complex('backup_destination_folder',
+                 [{'path'=>File.expand_path(''), 'scan_period'=>300, 'stable_state'=>1}],
+                 'Backup server destination folder, default is the relative local folder.')
+
+  def self.tmp_content_data_file
+    @@tmp_content_data_file
+  end
+
+  def self.local_dynamic_content_data
+    @@local_dynamic_content_data
+  end
 
   def run_backup_server
     Log.info('Start backup server')
@@ -34,22 +44,34 @@ module ContentServer
     # create general tmp dir
     FileUtils.mkdir_p(Params['tmp_path']) unless File.directory?(Params['tmp_path'])
     # init tmp content data file
-    tmp_content_data_file = Params['tmp_path'] + '/backup.data'
+    @@tmp_content_data_file = File.join(Params['tmp_path'], 'backup.data')
 
     if Params['enable_monitoring']
       Log.info("Initializing monitoring of process params on port:#{Params['process_monitoring_web_port']}")
-      Params['process_vars'] = ThreadSafeHash::ThreadSafeHash.new
-      Params['process_vars'].set('server_name', 'backup_server')
+      ::ContentServer::Globals.process_vars.set('server_name', 'backup_server')
     end
 
     # # # # # # # # # # # #
-    # Initialize/Start monitoring
+    # Initialize/start monitoring and destination folder
+    Params['backup_destination_folder'][0]['path']=File.expand_path(Params['backup_destination_folder'][0]['path'])
+    Log.info("backup_destination_folder is:#{Params['backup_destination_folder'][0]['path']}")
+    #adding destination folder to monitoring paths
+    Params['monitoring_paths'] << Params['backup_destination_folder'][0]
     Log.info('Start monitoring following directories:')
-    Params['monitoring_paths'].each {|path|
+    Params['monitoring_paths'].each { |path|
       Log.info("  Path:'#{path['path']}'")
     }
+
+    # Read here for initial content data that exist from previous system run
+    initial_content_data = ContentData::ContentData.new
+    content_data_path = Params['local_content_data_path']
+    initial_content_data.from_file(content_data_path) if File.exists?(content_data_path)
+    # Update local dynamic content with existing content
+    @@local_dynamic_content_data = ContentData::DynamicContentData.new
+    @@local_dynamic_content_data.update(initial_content_data)
+
     monitoring_events = Queue.new
-    fm = FileMonitoring::FileMonitoring.new
+    fm = FileMonitoring::FileMonitoring.new(@@local_dynamic_content_data)
     fm.set_event_queue(monitoring_events)
     # Start monitoring and writing changes to queue
     all_threads << Thread.new do
@@ -59,30 +81,10 @@ module ContentServer
     # # # # # # # # # # # # # #
     # Initialize/Start local indexer
     Log.debug1('Start indexer')
-    local_server_content_data_queue = Queue.new
-    queue_indexer = QueueIndexer.new(monitoring_events,
-                                     local_server_content_data_queue,
-                                     Params['local_content_data_path'])
+    queue_indexer = QueueIndexer.new(monitoring_events, @@local_dynamic_content_data)
     # Start indexing on demand and write changes to queue
     all_threads << queue_indexer.run
 
-    # # # # # # # # # # # # # # # # # # # # # # # # # # #
-    # Initialize/Start backup server content data sender
-    Log.debug1('Start backup server content data sender')
-    local_dynamic_content_data = ContentData::DynamicContentData.new
-    #content_data_sender = ContentDataSender.new(
-    #    Params['remote_server'],
-    #    Params['remote_listening_port'])
-    # Start sending to backup server
-    all_threads << Thread.new do
-      while true do
-        Log.debug1 'Waiting on local server content data queue.'
-        cd = local_server_content_data_queue.pop
-        #    content_data_sender.send_content_data(cd)
-        local_dynamic_content_data.update(cd)
-      end
-    end
-
     # # # # # # # # # # # # # # # # # # # # # # # #
     # Start dump local content data to file thread
     Log.debug1('Start dump local content data to file thread')
@@ -91,26 +93,24 @@ module ContentServer
       while true do
         if last_data_flush_time.nil? || last_data_flush_time + Params['data_flush_delay'] < Time.now.to_i
           Log.info "Writing local content data to #{Params['local_content_data_path']}."
-          local_dynamic_content_data.last_content_data.to_file(tmp_content_data_file)
+          @@local_dynamic_content_data.last_content_data.to_file(@@tmp_content_data_file)
           sleep(0.1)  # Added to prevent mv access issue
-          ::FileUtils.mv(tmp_content_data_file, Params['local_content_data_path'])
+          ::FileUtils.mv(@@tmp_content_data_file, Params['local_content_data_path'])
           last_data_flush_time = Time.now.to_i
         end
         sleep(1)
       end
     end
-    Params['backup_destination_folder'] = File.expand_path(Params['monitoring_paths'][0]['path'])
-    Log.info("backup_destination_folder is:#{Params['backup_destination_folder']}")
     content_server_dynamic_content_data = ContentData::DynamicContentData.new
     remote_content = ContentServer::RemoteContentClient.new(content_server_dynamic_content_data,
                                                             Params['content_server_hostname'],
                                                             Params['content_server_data_port'],
-                                                            Params['backup_destination_folder'])
+                                                            Params['backup_destination_folder'][0]['path'])
     all_threads.concat(remote_content.run())
 
     file_copy_client = FileCopyClient.new(Params['content_server_hostname'],
                                           Params['content_server_files_port'],
-                                          local_dynamic_content_data)
+                                          @@local_dynamic_content_data)
     all_threads.concat(file_copy_client.threads)
 
     # Each
@@ -118,16 +118,17 @@ module ContentServer
     all_threads << Thread.new do
       loop do
         sleep(Params['backup_check_delay'])
-        local_cd = local_dynamic_content_data.last_content_data()
+        local_cd = @@local_dynamic_content_data.last_content_data()
         remote_cd = content_server_dynamic_content_data.last_content_data()
-        diff = ContentData::ContentData.remove(local_cd, remote_cd)
-        #file_copy_client.request_copy(diff) unless diff.empty?
-        if !diff.empty?
-          Log.info('Start sync check. Backup and remote contents need a sync:')
-          Log.debug2("Backup content:\n#{local_cd}")
-          Log.debug2("Remote content:\n#{remote_cd}")
+        diff = ContentData.remove(local_cd, remote_cd)
+
+        Log.debug2("Backup content:\n#{local_cd}")
+        Log.debug2("Remote content:\n#{remote_cd}")
+        Log.debug2("Diff content:\n#{diff}")
+
+        unless diff.nil? || diff.empty?
+          Log.info('Start sync check. Backup and remote contents need a sync, requesting copy files:')
           Log.info("Missing contents:\n#{diff}")
-          Log.info('Requesting copy files')
           file_copy_client.request_copy(diff)
         else
           Log.info("Start sync check. Local and remote contents are equal. No sync required.")
@@ -140,57 +141,40 @@ module ContentServer
     if Params['enable_monitoring']
       monitoring_info = MonitoringInfo::MonitoringInfo.new()
       all_threads << Thread.new do
-        last_data_flush_time = nil
         mutex = Mutex.new
         while true do
-          if last_data_flush_time.nil? || last_data_flush_time + Params['process_vars_delay'] < Time.now
-            Params['process_vars'].set('time', Time.now)
-            Log.info("process_vars:monitoring queue size:#{monitoring_events.size}")
-            Params['process_vars'].set('monitoring queue', monitoring_events.size)
-            Log.info("process_vars:content data queue size:#{monitoring_events.size}")
-            Params['process_vars'].set('content data queue', local_server_content_data_queue.size)
-            #enable following line to see full list of object:count
-            #obj_array = ''
-            total_obj_count = 0
-            string_count = 0
-            file_count = 0
-            dir_count = 0
-            content_count = 0
-            index_agent_count = 0
-            indexer_patterns_count =  0
-            mutex.synchronize do
-              ObjectSpace.each_object(Class) {|obj|
-                obj_count_per_class = ObjectSpace.each_object(obj).count
-                #enable following line to see full list of object:count
-                #obj_array = "#{obj_array} * #{obj.name}:#{obj_count_per_class}"
-                total_obj_count = total_obj_count + obj_count_per_class
-              }
-              string_count = ObjectSpace.each_object(String).count
-              file_count = ObjectSpace.each_object(::FileMonitoring::FileStat).count
-              dir_count = ObjectSpace.each_object(::FileMonitoring::DirStat).count
-              content_count = ObjectSpace.each_object(::ContentData::ContentData).count
-              index_agent_count = ObjectSpace.each_object(::FileIndexing::IndexAgent).count
-              indexer_patterns_count =  ObjectSpace.each_object(::FileIndexing::IndexerPatterns).count
-            end
-            #enable following line to see full list of object:count
-            #Params['process_vars'].set('Live objs full', obj_array)
-            Log.info("process_vars:Live objs cnt:#{total_obj_count}")
-            Log.info("process_vars:Live String obj cnt:#{string_count}")
-            Log.info("process_vars:Live File obj cnt:#{file_count}")
-            Log.info("process_vars:Live Dir obj cnt:#{dir_count}")
-            Log.info("process_vars:Live Content data obj cnt:#{content_count}")
-            Log.info("process_vars:Live index agent obj cnt:#{index_agent_count}")
-            Log.info("process_vars:Live indexer patterns obj cnt:#{indexer_patterns_count}")
-            Params['process_vars'].set('Live objs cnt', total_obj_count)
-            Params['process_vars'].set('Live String obj cnt', string_count)
-            Params['process_vars'].set('Live File obj cnt', file_count)
-            Params['process_vars'].set('Live Dir obj cnt', dir_count)
-            Params['process_vars'].set('Live Content data obj cnt', content_count)
-            Params['process_vars'].set('Live index agent obj cnt', index_agent_count)
-            Params['process_vars'].set('Live indexer patterns obj cnt', indexer_patterns_count)
-            last_data_flush_time = Time.now
+          sleep(Params['process_vars_delay'])
+          ::ContentServer::Globals.process_vars.set('time', Time.now)
+          Log.debug3("process_vars:monitoring queue size:#{monitoring_events.size}")
+          ::ContentServer::Globals.process_vars.set('monitoring queue', monitoring_events.size)
+          #enable following line to see full list of object:count
+          #obj_array = ''
+          total_obj_count = 0
+          string_count = 0
+          file_count = 0
+          dir_count = 0
+          content_count = 0
+          mutex.synchronize do
+            ObjectSpace.each_object(Class) {|obj|
+              obj_count_per_class = ObjectSpace.each_object(obj).count
+              #enable following line to see full list of object:count
+              #obj_array = "#{obj_array} * #{obj.name}:#{obj_count_per_class}"
+              total_obj_count = total_obj_count + obj_count_per_class
+            }
+            string_count = ObjectSpace.each_object(String).count
+            file_count = ObjectSpace.each_object(::FileMonitoring::FileStat).count
+            dir_count = ObjectSpace.each_object(::FileMonitoring::DirStat).count
+            content_count = ObjectSpace.each_object(::ContentData::ContentData).count
           end
-          sleep(0.3)
+          #enable following line to see full list of object:count
+          #::ContentServer::Globals.process_vars.set('Live objs full', obj_array)
+          Log.debug3("process_vars:Live objs cnt:#{total_obj_count}")
+          ::ContentServer::Globals.process_vars.set('Live objs cnt', total_obj_count)
+          Log.debug3("process_vars:Live String obj cnt:#{string_count}")
+          Log.debug3("process_vars:Live File obj cnt:#{file_count}")
+          Log.debug3("process_vars:Live Dir obj cnt:#{dir_count}")
+          Log.debug3("process_vars:Live Content data obj cnt:#{content_count}")
+          ::ContentServer::Globals.process_vars.set('Live String obj cnt', string_count)
         end
       end
     end

data/lib/content_server/content_server.rb

@@ -9,32 +9,41 @@ require 'content_server/queue_copy'
 require 'content_server/remote_content'
 require 'file_indexing'
 require 'file_monitoring'
+require 'content_server/globals'
 require 'log'
 require 'networking/tcp'
 require 'params'
-require 'process_monitoring/thread_safe_hash'
 require 'process_monitoring/monitoring_info'
 
 # Content server. Monitors files, index local files, listen to backup server content,
 # copy changes and new files to backup server.
 module ContentServer
   # Content server specific flags.
-  Params.integer('local_files_port', 4444, 'Remote port in backup server to copy files.')
-  Params.integer('local_content_data_port', 3333, 'Listen to incoming content data requests.')
+  Params.integer('local_files_port', 4444, 'Remote port in backup server to copy files')
+  Params.integer('local_content_data_port', 3333, 'Listen to incoming content data requests')
+  Params.string('local_server_name', `hostname`.strip, 'local server name')
   Params.path('tmp_path', '~/.bbfs/tmp', 'tmp path for temporary files')
 
+  def self.tmp_content_data_file
+    @@tmp_content_data_file
+  end
+
+  def self.local_dynamic_content_data
+    @@local_dynamic_content_data
+  end
+
   def run_content_server
     Log.info('Content server start')
     all_threads = []
+
     # create general tmp dir
     FileUtils.mkdir_p(Params['tmp_path']) unless File.directory?(Params['tmp_path'])
     # init tmp content data file
-    tmp_content_data_file = Params['tmp_path'] + '/content.data'
+    @@tmp_content_data_file = File.join(Params['tmp_path'], 'content.data')
 
     if Params['enable_monitoring']
       Log.info("Initializing monitoring of process params on port:#{Params['process_monitoring_web_port']}")
-      Params['process_vars'] = ThreadSafeHash::ThreadSafeHash.new
-      Params['process_vars'].set('server_name', 'content_server')
+      ::ContentServer::Globals.process_vars.set('server_name', 'content_server')
     end
 
     # # # # # # # # # # # #
@@ -44,7 +53,17 @@ module ContentServer
       Log.info("  Path:'#{path['path']}'")
     }
     monitoring_events = Queue.new
-    fm = FileMonitoring::FileMonitoring.new
+
+    # Read here for initial content data that exist from previous system run
+    initial_content_data = ContentData::ContentData.new
+    content_data_path = Params['local_content_data_path']
+    initial_content_data.from_file(content_data_path) if File.exists?(content_data_path)
+    # Update local dynamic content with existing content
+    @@local_dynamic_content_data = ContentData::DynamicContentData.new
+    @@local_dynamic_content_data.update(initial_content_data)
+
+    #Start files monitor taking into consideration  existing content  data
+    fm = FileMonitoring::FileMonitoring.new(@@local_dynamic_content_data)
     fm.set_event_queue(monitoring_events)
     # Start monitoring and writing changes to queue
     all_threads << Thread.new do
@@ -54,26 +73,10 @@ module ContentServer
     # # # # # # # # # # # # # #
     # Initialize/Start local indexer
     Log.debug1('Start indexer')
-    local_server_content_data_queue = Queue.new
-    queue_indexer = QueueIndexer.new(monitoring_events,
-                                     local_server_content_data_queue,
-                                     Params['local_content_data_path'])
+    queue_indexer = QueueIndexer.new(monitoring_events, @@local_dynamic_content_data)
     # Start indexing on demand and write changes to queue
     all_threads << queue_indexer.run
 
-    # # # # # # # # # # # # # # # # # # # # # #
-    # Initialize/Start content data comparator
-    Log.debug1('Start content data comparator')
-    local_dynamic_content_data = ContentData::DynamicContentData.new
-    all_threads << Thread.new do  # TODO(kolman): Seems like redundant, check how to update dynamic directly.
-      while true do
-        # Note: This thread should be the only consumer of local_server_content_data_queue
-        Log.debug1 'Waiting on local server content data.'
-        local_server_content_data = local_server_content_data_queue.pop
-        local_dynamic_content_data.update(local_server_content_data)
-      end
-    end
-
     # # # # # # # # # # # # # # # # # # # # # # # #
     # Start dump local content data to file thread
     Log.debug1('Start dump local content data to file thread')
@@ -82,16 +85,16 @@ module ContentServer
       while true do
         if last_data_flush_time.nil? || last_data_flush_time + Params['data_flush_delay'] < Time.now.to_i
           Log.info "Writing local content data to #{Params['local_content_data_path']}."
-          local_dynamic_content_data.last_content_data.to_file(tmp_content_data_file)
+          @@local_dynamic_content_data.last_content_data.to_file(@@tmp_content_data_file)
           sleep(0.1)  # Added to prevent mv access issue
-          ::FileUtils.mv(tmp_content_data_file, Params['local_content_data_path'])
+          ::FileUtils.mv(@@tmp_content_data_file, Params['local_content_data_path'])
           last_data_flush_time = Time.now.to_i
         end
         sleep(1)
       end
     end
 
-    remote_content_client = RemoteContentServer.new(local_dynamic_content_data,
+    remote_content_client = RemoteContentServer.new(@@local_dynamic_content_data,
                                                     Params['local_content_data_port'])
     all_threads << remote_content_client.tcp_thread
 
@@ -110,56 +113,43 @@ module ContentServer
         last_data_flush_time = nil
         mutex = Mutex.new
         while true do
-          if last_data_flush_time.nil? || last_data_flush_time + Params['process_vars_delay'] < Time.now
-            Params['process_vars'].set('time', Time.now)
-            Log.info("process_vars:monitoring queue size:#{monitoring_events.size}")
-            Params['process_vars'].set('monitoring queue', monitoring_events.size)
-            Log.info("process_vars:content data queue size:#{monitoring_events.size}")
-            Params['process_vars'].set('content data queue', local_server_content_data_queue.size)
-            Log.info("process_vars:copy files events queue size:#{copy_files_events.size}")
-            Params['process_vars'].set('copy files events queue', copy_files_events.size)
-            #enable following line to see full list of object:count
-            #obj_array = ''
-            total_obj_count = 0
-            string_count = 0
-            file_count = 0
-            dir_count = 0
-            content_count = 0
-            index_agent_count = 0
-            indexer_patterns_count =  0
-            mutex.synchronize do
-              ObjectSpace.each_object(Class) {|obj|
-                obj_count_per_class = ObjectSpace.each_object(obj).count
-                #enable following line to see full list of object:count
-                #obj_array = "#{obj_array} * #{obj.name}:#{obj_count_per_class}"
-                total_obj_count = total_obj_count + obj_count_per_class
-              }
-              string_count = ObjectSpace.each_object(String).count
-              file_count = ObjectSpace.each_object(::FileMonitoring::FileStat).count
-              dir_count = ObjectSpace.each_object(::FileMonitoring::DirStat).count
-              content_count = ObjectSpace.each_object(::ContentData::ContentData).count
-              index_agent_count = ObjectSpace.each_object(::FileIndexing::IndexAgent).count
-              indexer_patterns_count =  ObjectSpace.each_object(::FileIndexing::IndexerPatterns).count
-            end
-            #enable following line to see full list of object:count
-            #Params['process_vars'].set('Live objs full', obj_array)
-            Log.info("process_vars:Live objs cnt:#{total_obj_count}")
-            Log.info("process_vars:Live String obj cnt:#{string_count}")
-            Log.info("process_vars:Live File obj cnt:#{file_count}")
-            Log.info("process_vars:Live Dir obj cnt:#{dir_count}")
-            Log.info("process_vars:Live Content data obj cnt:#{content_count}")
-            Log.info("process_vars:Live index agent obj cnt:#{index_agent_count}")
-            Log.info("process_vars:Live indexer patterns obj cnt:#{indexer_patterns_count}")
-            Params['process_vars'].set('Live objs cnt', total_obj_count)
-            Params['process_vars'].set('Live String obj cnt', string_count)
-            Params['process_vars'].set('Live File obj cnt', file_count)
-            Params['process_vars'].set('Live Dir obj cnt', dir_count)
-            Params['process_vars'].set('Live Content data obj cnt', content_count)
-            Params['process_vars'].set('Live index agent obj cnt', index_agent_count)
-            Params['process_vars'].set('Live indexer patterns obj cnt', indexer_patterns_count)
-            last_data_flush_time = Time.now
+          sleep(Params['process_vars_delay'])
+          ::ContentServer::Globals.process_vars.set('time', Time.now)
+          Log.debug3("process_vars:monitoring queue size:#{monitoring_events.size}")
+          ::ContentServer::Globals.process_vars.set('monitoring queue', monitoring_events.size)
+          Log.debug3("process_vars:copy files events queue size:#{copy_files_events.size}")
+          ::ContentServer::Globals.process_vars.set('copy files events queue', copy_files_events.size)
+          #enable following line to see full list of object:count
+          #obj_array = ''
+          total_obj_count = 0
+          string_count = 0
+          file_count = 0
+          dir_count = 0
+          content_count = 0
+          mutex.synchronize do
+            ObjectSpace.each_object(Class) {|obj|
+              obj_count_per_class = ObjectSpace.each_object(obj).count
+              #enable following line to see full list of object:count
+              #obj_array = "#{obj_array} * #{obj.name}:#{obj_count_per_class}"
+              total_obj_count = total_obj_count + obj_count_per_class
+            }
+            string_count = ObjectSpace.each_object(String).count
+            file_count = ObjectSpace.each_object(::FileMonitoring::FileStat).count
+            dir_count = ObjectSpace.each_object(::FileMonitoring::DirStat).count
+            content_count = ObjectSpace.each_object(::ContentData::ContentData).count
           end
-          sleep(0.3)
+          #enable following line to see full list of object:count
+          #process_vars.set('Live objs full', obj_array)
+          Log.debug3("process_vars:Live objs cnt:#{total_obj_count}")
+          Log.debug3("process_vars:Live String obj cnt:#{string_count}")
+          Log.debug3("process_vars:Live File obj cnt:#{file_count}")
+          Log.debug3("process_vars:Live Dir obj cnt:#{dir_count}")
+          Log.debug3("process_vars:Live Content data obj cnt:#{content_count}")
+          ::ContentServer::Globals.process_vars.set('Live objs cnt', total_obj_count)
+          ::ContentServer::Globals.process_vars.set('Live String obj cnt', string_count)
+          ::ContentServer::Globals.process_vars.set('Live File obj cnt', file_count)
+          ::ContentServer::Globals.process_vars.set('Live Dir obj cnt', dir_count)
+          ::ContentServer::Globals.process_vars.set('Live Content data obj cnt', content_count)
         end
       end
     end

data/lib/content_server/file_streamer.rb

@@ -2,6 +2,7 @@ require 'tempfile'
 require 'thread'
 
 require 'file_indexing/index_agent'
+require 'content_server/globals'
 require 'log'
 require 'params'
 
@@ -12,9 +13,6 @@ module ContentServer
                  'Max number of content bytes to send in one chunk.')
   Params.integer('file_streaming_timeout', 5*60,
                  'If no action is taken on a file streamer, abort copy.')
-  Params.path('backup_destination_folder', '',
-              'Backup server destination folder, default is the relative local folder.')
-
   class Stream
     attr_reader :checksum, :path, :tmp_path, :file, :size
     def initialize(checksum, path, file, size)
@@ -59,24 +57,40 @@ module ContentServer
 
     def copy_another_chuck(checksum)
       @stream_queue << [:COPY_CHUNK, checksum]
+      if Params['enable_monitoring']
+        ::ContentServer::Globals.process_vars.set('File Streamer queue', @stream_queue.size)
+      end
     end
 
     def start_streaming(checksum, path)
       @stream_queue << [:NEW_STREAM, [checksum, path]]
+      if Params['enable_monitoring']
+        ::ContentServer::Globals.process_vars.set('File Streamer queue', @stream_queue.size)
+      end
     end
 
     def abort_streaming(checksum)
       @stream_queue << [:ABORT_STREAM, checksum]
+      if Params['enable_monitoring']
+        ::ContentServer::Globals.process_vars.set('File Streamer queue', @stream_queue.size)
+      end
     end
 
     def reset_streaming(checksum, new_offset)
       @stream_queue << [:RESET_STREAM, [checksum, new_offset]]
+      if Params['enable_monitoring']
+        ::ContentServer::Globals.process_vars.set('File Streamer queue', @stream_queue.size)
+      end
     end
 
     def run
       return Thread.new do
         loop {
-          checksum = handle(@stream_queue.pop)
+          stream_pop = @stream_queue.pop
+          if Params['enable_monitoring']
+            ::ContentServer::Globals.process_vars.set('File Streamer queue', @stream_queue.size)
+          end
+          checksum = handle(stream_pop)
         }
       end
     end
@@ -87,6 +101,9 @@ module ContentServer
         checksum, path = content
         reset_stream(checksum, path, 0)
         @stream_queue << [:COPY_CHUNK, checksum] if @streams.key?(checksum)
+        if Params['enable_monitoring']
+          ::ContentServer::Globals.process_vars.set('File Streamer queue', @stream_queue.size)
+        end
       elsif type == :ABORT_STREAM
         checksum = content
         Stream.close_delete_stream(checksum, @streams)
@@ -94,6 +111,9 @@ module ContentServer
         checksum, new_offset = content
         reset_stream(checksum, nil, new_offset)
         @stream_queue << [:COPY_CHUNK, checksum] if @streams.key?(checksum)
+        if Params['enable_monitoring']
+          ::ContentServer::Globals.process_vars.set('File Streamer queue', @stream_queue.size)
+        end
       elsif type == :COPY_CHUNK
         checksum = content
         if @streams.key?(checksum)
@@ -191,11 +211,12 @@ module ContentServer
 
     # open new stream
     def handle_new_stream(file_checksum, file_size)
+      Log.info("enter handle_new_stream")
       # final destination path
       tmp_path = FileReceiver.destination_filename(
-          File.join(Params['backup_destination_folder'], 'tmp'),
+          File.join(Params['backup_destination_folder'][0]['path'], 'tmp'),
           file_checksum)
-      path = FileReceiver.destination_filename(Params['backup_destination_folder'],
+      path = FileReceiver.destination_filename(Params['backup_destination_folder'][0]['path'],
                                                file_checksum)
       if File.exists?(path)
         Log.warning("File already exists (#{path}) not writing.")
@@ -204,7 +225,7 @@ module ContentServer
         # The file will be moved from tmp location once the transfer will be done
         # system will use the checksum and some more unique key for tmp file name
         FileUtils.makedirs(File.dirname(tmp_path)) unless File.directory?(File.dirname(tmp_path))
-        tmp_file = file = File.new(tmp_path, 'wb')
+        tmp_file = File.new(tmp_path, 'wb')
         @streams[file_checksum] = Stream.new(file_checksum, tmp_path, tmp_file, file_size)
       end
     end
@@ -234,7 +255,7 @@ module ContentServer
       # Should always be true, unless file creation failed.
       if @streams.key?(file_checksum)
         # Make the directory if does not exists.
-        path = FileReceiver.destination_filename(Params['backup_destination_folder'],
+        path = FileReceiver.destination_filename(Params['backup_destination_folder'][0]['path'],
                                                  file_checksum)
         Log.debug1("Moving tmp file #{@streams[file_checksum].path} to #{path}")
         Log.debug1("Creating directory: #{path}")

data/lib/content_server/globals.rb

@@ -0,0 +1,10 @@
+require 'process_monitoring/thread_safe_hash'
+
+module ContentServer
+  class Globals
+    @@process_vars = ThreadSafeHash::ThreadSafeHash.new
+    def self.process_vars
+      @@process_vars
+    end
+  end
+end

data/lib/content_server/queue_copy.rb

@@ -2,6 +2,7 @@ require 'thread'
 
 require 'content_server/file_streamer'
 require 'file_indexing/index_agent'
+require 'content_server/globals'
 require 'log'
 require 'networking/tcp'
 require 'params'
@@ -55,12 +56,11 @@ module ContentServer
           if message_type == :COPY_MESSAGE
             Log.debug1 "Copy files 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.debug1("Sending ack for: #{instance.checksum}")
-                @backup_tcp.send_obj([:ACK_MESSAGE, [instance.checksum, Time.now.to_i]])
+            message_content.each_instance { |checksum, size, content_mod_time, instance_mod_time, server, path|
+              if !@copy_prepare.key?(checksum) || !@copy_prepare[checksum][1]
+                @copy_prepare[checksum] = [path, false]
+                Log.debug1("Sending ack for: #{checksum}")
+                @backup_tcp.send_obj([:ACK_MESSAGE, [checksum, Time.now.to_i]])
               end
             }
           elsif message_type == :ACK_MESSAGE
@@ -72,19 +72,23 @@ module ContentServer
                        "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}")
+            if ack
+              if (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 to backup server. content: #{checksum} path:#{path}."
+                  @file_streamer.start_streaming(checksum, path)
+                  # Ack received, setting prepare to true
+                  @copy_prepare[checksum][1] = true
+                end
               else
-                path = @copy_prepare[checksum][0]
-                Log.info "Streaming to backup server. content: #{checksum} path:#{path}."
-                @file_streamer.start_streaming(checksum, path)
-                # Ack received, setting prepare to true
-                @copy_prepare[checksum][1] = true
+                Log.debug1("Ack timed out span: #{Time.now.to_i - timestamp} > " \
+                           "timeout: #{Params['ack_timeout']}")
               end
             else
-              Log.debug1("Ack timed out span: #{Time.now.to_i - timestamp} > " \
-                           "timeout: #{Params['ack_timeout']}")
+              Log.debug1('Ack is false');
             end
           elsif message_type == :COPY_CHUNK_FROM_REMOTE
             checksum = message_content
@@ -122,7 +126,6 @@ module ContentServer
   class FileCopyClient
     def initialize(host, port, dynamic_content_data)
       @local_queue = Queue.new
-      start_process_var_monitoring
       @dynamic_content_data = dynamic_content_data
       @tcp_client = Networking::TCPClient.new(host, port, method(:handle_message))
       @file_receiver = FileReceiver.new(method(:done_copy),
@@ -130,6 +133,10 @@ module ContentServer
                                         method(:reset_copy))
       @local_thread = Thread.new do
         loop do
+          pop_queue = @local_queue.pop
+          if Params['enable_monitoring']
+            ::ContentServer::Globals.process_vars.set('File Copy Client queue', @local_queue.size)
+          end
           handle(@local_queue.pop)
         end
       end
@@ -137,22 +144,6 @@ module ContentServer
       Log.debug3("initialize FileCopyClient  host:#{host}  port:#{port}")
     end
 
-    def start_process_var_monitoring
-      if Params['enable_monitoring']
-        @process_var_thread = Thread.new do
-          last_data_flush_time = nil
-          while true do
-            if last_data_flush_time.nil? || last_data_flush_time + Params['process_vars_delay'] < Time.now
-              Log.info("process_vars:FileCopyClient queue size:#{@local_queue.size}")
-              Params['process_vars'].set('File Copy Client queue', @local_queue.size)
-              last_data_flush_time = Time.now
-            end
-            sleep(0.3)
-          end
-        end
-      end
-    end
-
     def threads
       ret = [@local_thread]
       ret << @tcp_client.tcp_thread if @tcp_client != nil
@@ -172,13 +163,18 @@ module ContentServer
     end
 
     def done_copy(local_file_checksum, local_path)
-      Params['process_vars'].inc('num_files_received')
+      if Params['enable_monitoring']
+        ::ContentServer::Globals.process_vars.inc('num_files_received')
+      end
       Log.debug1("Done copy file: #{local_path}, #{local_file_checksum}")
     end
 
     def handle_message(message)
       Log.debug3('QueueFileReceiver handle message')
       @local_queue.push(message)
+      if Params['enable_monitoring']
+        ::ContentServer::Globals.process_vars.set('File Copy Client queue', @local_queue.size)
+      end
     end
 
     # This is a function which receives the messages (file or ack) and return answer in case
@@ -186,8 +182,8 @@ module ContentServer
     def handle(message)
       message_type, message_content = message
       if message_type == :SEND_COPY_MESSAGE
-        Log.debug1("Requesting file (content data) to copy.")
-        Log.debug2("File requested: #{message_content.to_s}")
+        Log.debug1("Requesting files to copy.")
+        Log.debug2("Files requested: #{message_content.to_s}")
         bytes_written = @tcp_client.send_obj([:COPY_MESSAGE, message_content])
         Log.debug2("Sending copy message succeeded? bytes_written: #{bytes_written}.")
       elsif message_type == :COPY_CHUNK

data/lib/content_server/queue_indexer.rb

@@ -1,110 +1,89 @@
 require 'file_indexing/index_agent'
 require 'file_indexing/indexer_patterns'
+require 'content_server/globals'
 require 'log'
 require 'params'
 
 module ContentServer
 
-
   # 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)
+    def initialize(input_queue, local_dynamic_content_data)
       @input_queue = input_queue
-      @output_queue = output_queue
-      @content_data_path = content_data_path
+      @local_dynamic_content_data = local_dynamic_content_data
     end
 
+    # index files and add to copy queue
+    # delete directory with it's sub files
+    # delete file
     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.debug1('Shallow checking content data:')
-        if shallow_check(instance)
-          Log.debug1("exists: #{instance.full_path}")
-          server_content_data.add_content(tmp_content_data.contents[instance.checksum])
-          server_content_data.add_instance(instance)
-        else
-          Log.debug1("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.debug1 'Waiting on index input queue.'
-          (state, is_dir, path) = @input_queue.pop
-          Log.debug1 "index event: state:#{state}, dir?#{is_dir}, path:#{path}."
-
-          # index files and add to copy queue
-          # delete directory with it's sub files
-          # delete file
+          (state, is_dir, path, mtime, size) = @input_queue.pop
+          Log.debug1 "index event: state:#{state}, dir?#{is_dir}, path:#{path}, mtime:#{mtime}, size:#{size}."
           if state == FileMonitoring::FileStatEnum::STABLE && !is_dir
-            Log.debug1 "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.debug1("Failed files: #{index_agent.failed_files.to_a.join(',')}.") \
-                  if !index_agent.failed_files.empty?
-            Log.debug1("indexed content #{index_agent.indexed_content}.")
-            server_content_data.merge index_agent.indexed_content
-if Params['enable_monitoring']
-              Params['process_vars'].inc('indexed_files')
+            # Calculating checksum
+            instance_stats = @local_dynamic_content_data.stats_by_location([Params['local_server_name'], path])
+            Log.debug1("instance !#{instance_stats}! mtime: #{mtime.to_i}, size: #{size}")
+            if instance_stats.nil? || mtime.to_i != instance_stats[1] || size != instance_stats[0]
+              Log.info "Indexing file:'#{path}'."
+              checksum = calc_SHA1(path)
+              if Params['enable_monitoring']
+                ::ContentServer::Globals.process_vars.inc('indexed_files')
+              end
+              Log.debug1("Index info:checksum:#{checksum} size:#{size} time:#{mtime.to_i}")
+              Log.debug1('Adding index to content data. put in queue for dynamic update.')
+              @local_dynamic_content_data.add_instance(checksum, size, Params['local_server_name'], path, mtime.to_i)
+            else
+              Log.info("Skip file #{path} indexing (shallow check passed)")
             end
           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.debug1("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
-            end
+            Log.debug2("NonExisting/Changed (file): #{path}")
+            # Remove file but only when non-existing.
+            Log.debug1("File to remove: #{path}")
+            @local_dynamic_content_data.remove_instance([Params['local_server_name'],path])
           elsif state == FileMonitoring::FileStatEnum::NON_EXISTING && is_dir
-            Log.debug1("NonExisting/Changed: #{path}")
+            Log.debug2("NonExisting/Changed (dir): #{path}")
             # Remove directory but only when non-existing.
             Log.debug1("Directory to remove: #{path}")
-            global_dir = FileIndexing::IndexAgent.global_path(path)
-            server_content_data = ContentData::ContentData.remove_directory(
-                server_content_data, global_dir)
+            @local_dynamic_content_data.remove_directory(path, Params['local_server_name'])
           else
             Log.debug1("This case should not be handled: #{state}, #{is_dir}, #{path}.")
           end
-          
-          Log.debug1 '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
 
+    # Opens file and calculates SHA1 of it's content, returns SHA1
+    def calc_SHA1(path)
+      begin
+        digest = Digest::SHA1.new
+        File.open(path, 'rb') { |f|
+          while buffer = f.read(65536) do
+            digest << buffer
+          end
+        }
+      rescue
+       Log.warning("Monitored path'#{path}' does not exist. Probably file changed")
+      end
+      return digest.hexdigest.downcase
+    end
+
+    # Remove when not needed.
     # 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
+    #def shallow_check(file_name, file_size, file_mod_time)
+    #  shallow_instance = FileIndexing::IndexAgent.create_shallow_instance(file_name)
+    #  return false unless shallow_instance
+    #  return (shallow_instance[0] == file_size &&
+    #      shallow_instance[2] == file_mod_time)
+    #end
 
   end  # class QueueIndexer
 end

data/lib/content_server/remote_content.rb

@@ -25,7 +25,6 @@ module ContentServer
     def receive_content(message)
       Log.debug1("Backup server received Remote content data:#{message.to_s}")
       Log.info("Backup server received Remote content data")
-      ref = @dynamic_content_data.last_content_data
       @dynamic_content_data.update(message)
       @last_fetch_timestamp = Time.now.to_i
 

data/lib/content_server/version.rb

@@ -1,3 +1,3 @@
   module ContentServer
-    VERSION = "1.0.3"
+    VERSION = "1.1.0"
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: content_server
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-12 00:00:00.000000000 Z
+date: 2013-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: content_data
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: file_indexing
   requirement: !ruby/object:Gem::Requirement
@@ -34,7 +34,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: file_monitoring
   requirement: !ruby/object:Gem::Requirement
@@ -50,7 +50,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.3
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +58,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.3
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: log
   requirement: !ruby/object:Gem::Requirement
@@ -66,7 +66,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -74,7 +74,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: networking
   requirement: !ruby/object:Gem::Requirement
@@ -82,7 +82,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -90,7 +90,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: params
   requirement: !ruby/object:Gem::Requirement
@@ -98,7 +98,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -106,7 +106,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: process_monitoring
   requirement: !ruby/object:Gem::Requirement
@@ -114,7 +114,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -122,7 +122,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -146,7 +146,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -154,7 +154,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: content_data
   requirement: !ruby/object:Gem::Requirement
@@ -162,7 +162,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -170,7 +170,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: file_indexing
   requirement: !ruby/object:Gem::Requirement
@@ -178,7 +178,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -186,7 +186,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: file_monitoring
   requirement: !ruby/object:Gem::Requirement
@@ -194,7 +194,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.3
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -202,7 +202,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.3
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: log
   requirement: !ruby/object:Gem::Requirement
@@ -210,7 +210,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -218,7 +218,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: networking
   requirement: !ruby/object:Gem::Requirement
@@ -226,7 +226,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -234,7 +234,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: params
   requirement: !ruby/object:Gem::Requirement
@@ -242,7 +242,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -250,7 +250,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: process_monitoring
   requirement: !ruby/object:Gem::Requirement
@@ -258,7 +258,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -266,7 +266,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -290,7 +290,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -298,7 +298,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
 description: Monitor and Index a directory and back it up to backup server.
 email: bbfsdev@gmail.com
 executables:
@@ -310,6 +310,7 @@ files:
 - lib/content_server.rb
 - lib/content_server/file_streamer.rb
 - lib/content_server/queue_copy.rb
+- lib/content_server/globals.rb
 - lib/content_server/content_server.rb
 - lib/content_server/content_receiver.rb
 - lib/content_server/remote_content.rb