content_server 1.2.1 → 1.3.0

data/bin/backup_server

@@ -20,8 +20,6 @@ ContentServer.init_globals
 
 Thread.abort_on_exception = true  # TODO (genadyp) should be treated globally? by param for example.
 
-retries = 0  # number of retries to run a server
-
 begin
   RunInBackground.run { ContentServer.run_backup_server }
 rescue SystemExit, SignalException => exception
@@ -31,11 +29,6 @@ rescue SystemExit, SignalException => exception
   exit
 rescue Exception => exception
   ContentServer.handle_program_termination(exception)
-  if retries > 0
-    Log.debug1("Restarting (retries:#{retries}).")
-  else
-    Log.debug1("Exiting...")
-    Log.flush
-  end
-  retries -= 1
-end while retries >= 0
+  Log.flush
+  exit
+end

data/bin/content_server

@@ -17,8 +17,6 @@ ContentServer.init_globals
 
 Thread.abort_on_exception = true  # TODO (genadyp) should be treated globally? by param for example.
 
-retries = 0  # number of retries to run a server
-
 begin
   RunInBackground.run { ContentServer.run_content_server }
 rescue SystemExit, SignalException => exception
@@ -28,11 +26,6 @@ rescue SystemExit, SignalException => exception
   exit
 rescue Exception => exception
   ContentServer.handle_program_termination(exception)
-  if retries > 0
-    Log.debug1("Restarting (retries:#{retries}).")
-  else
-    Log.debug1("Exiting...")
-    Log.flush
-  end
-  retries -= 1
-end while retries >= 0
+  Log.flush
+  exit
+end

data/bin/testing_memory

@@ -24,8 +24,6 @@ ContentServer.init_globals
 
 Thread.abort_on_exception = true
 
-retries = 0  # number of retries to run a server
-
 begin
   case Params['server_to_test']
     when 'content'
@@ -35,7 +33,6 @@ begin
     else
       raise ArgumentError.new "Incorrect server_to_test parameter value: #{Params['server_to_test']}"
   end
-  retries -=1
 
 rescue SystemExit, SignalException => exc
   # TODO (genadyp) do we need to trap signals by types?
@@ -50,11 +47,6 @@ rescue Exception => exc
                 "#{exc.backtrace.join("\n")}")
   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}).")
-  else
-    Log.debug1("Exiting...")
-    Log.flush
-  end
-  retries -= 1
-end while retries >= 0
+  Log.flush
+  exit
+end

data/bin/testing_server

@@ -22,8 +22,6 @@ ContentServer.init_globals
 
 Thread.abort_on_exception = true
 
-retries = 0  # number of retries to run a server
-
 begin
   case Params['server_to_test']
   when 'content'
@@ -47,11 +45,6 @@ rescue Exception => exc
                 "#{exc.backtrace.join("\n")}")
   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}).")
-  else
-    Log.debug1("Exiting...")
-    Log.flush
-  end
-  retries -= 1
-end while retries >= 0
+  Log.flush
+  exit
+end

data/lib/content_data/content_data.rb

@@ -144,7 +144,7 @@ module ContentData
                                     modification_time]
       else
         if size != content_info[0]
-          Log.warning 'File size different from content size while same checksum'
+          Log.warning('File size different from content size while same checksum')
           Log.warning("instance location:server:'#{location[0]}'  path:'#{location[1]}'")
           Log.warning("instance mod time:'#{modification_time}'")
         end
@@ -168,13 +168,6 @@ module ContentData
       @instances_info.has_key?([server, path])
     end
 
-    def stats_by_location(location)
-      checksum = @instances_info[location]
-      content_info = @contents_info[checksum]
-      return nil if content_info.nil?
-      return [content_info[0], content_info[1][location]]
-    end
-
     # removes an instance record both in @instances_info and @instances_info.
     # input params: server & path - are the instance unique key (called location)
     # removes also the content, if content becomes empty after removing the instance
@@ -260,11 +253,11 @@ module ContentData
       file = File.open(filename, 'w')
       file.write("#{@contents_info.length}\n")
       each_content { |checksum, size, content_mod_time|
-        file.write("#{checksum},#{size},#{content_mod_time}\n")
+        file.write("#{checksum},#{size},#{Time.at(content_mod_time)}\n")
       }
       file.write("#{@instances_info.length}\n")
       each_instance { |checksum, size, _, instance_mod_time, server, path|
-        file.write("#{checksum},#{size},#{server},#{path},#{instance_mod_time}\n")
+        file.write("#{checksum},#{size},#{server},#{path},#{Time.at(instance_mod_time)}\n")
       }
       file.close
     end
@@ -278,7 +271,7 @@ module ContentData
       i += 1
       number_of_instances.times {
         if lines[i].nil?
-          Log.warning "line ##{i} is nil !!!, Backing filename: #{filename} to #{filename}.bad"
+          Log.warning("line ##{i} is nil !!!, Backing filename: #{filename} to #{filename}.bad")
           FileUtils.cp(filename, "#{filename}.bad")
           Log.warning("Lines:\n#{lines[i].join("\n")}")
         else
@@ -297,7 +290,7 @@ module ContentData
                        parameters[1].to_i,
                        parameters[2],
                        parameters[3],
-                       parameters[4].to_i)
+                       DateTime.parse(parameters[4]).to_time.to_i)
         end
         i += 1
       }
@@ -397,19 +390,19 @@ module ContentData
         if File.size(path) != size
           is_valid = false
           err_msg = "#{path} size #{File.size(path)} differs from indexed size #{size}"
-          Log.warning err_msg
+          Log.warning(err_msg)
         end
         #if ContentData.format_time(File.mtime(path)) != instance.modification_time
         if File.mtime(path).to_i != instance_mtime
           is_valid = false
           err_msg = "#{path} modification time #{File.mtime(path).to_i} differs from " \
             + "indexed #{instance_mtime}"
-          Log.warning err_msg
+          Log.warning(err_msg)
         end
       else
         is_valid = false
         err_msg = "Indexed file #{path} doesn't exist"
-        Log.warning err_msg
+        Log.warning(err_msg)
       end
       is_valid
     end
@@ -430,7 +423,7 @@ module ContentData
           true
         else
           err_msg = "#{path} checksum #{current_checksum} differs from indexed #{instance_checksum}"
-          Log.warning err_msg
+          Log.warning(err_msg)
           false
         end
       else

data/lib/content_server/backup_server.rb

@@ -39,19 +39,19 @@ module ContentServer
     $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']}")
+      Log.info("Initializing monitoring of process params on port:%s", Params['process_monitoring_web_port'])
       $process_vars.set('server_name', 'backup_server')
     end
 
     # # # # # # # # # # # #
     # 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']}")
+    Log.info("backup_destination_folder is:%s", 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|
-      Log.info("  Path:'#{path['path']}'")
+      Log.info("  Path:'%s'", path['path'])
     }
 
     # initial global local content data object
@@ -60,12 +60,14 @@ module ContentServer
 
     # Read here for initial content data that exist from previous system run
     content_data_path = Params['local_content_data_path']
+    last_content_data_id = nil
     if File.exists?(content_data_path) and !File.directory?(content_data_path)
-      Log.info("reading initial content data that exist from previous system run from file:#{content_data_path}")
+      Log.info("reading initial content data that exist from previous system run from file:%s", content_data_path)
       $local_content_data.from_file(content_data_path)
+      last_content_data_id = $local_content_data.unique_id
     else
       if File.directory?(content_data_path)
-        raise("Param:'local_content_data_path':'#{Params['local_content_data_path']}'cannot be a directory name")
+        raise("Param:'local_content_data_path':'%s' cannot be a directory name", Params['local_content_data_path'])
       end
       # create directory if needed
       dir = File.dirname(Params['local_content_data_path'])
@@ -93,7 +95,6 @@ module ContentServer
     Log.debug1('Init thread: flush local content data to file')
     all_threads << Thread.new do
       FileUtils.mkdir_p(Params['tmp_path']) unless File.directory?(Params['tmp_path'])
-      last_content_data_id = nil
       loop{
         sleep(Params['data_flush_delay'])
         Log.info('Start flush local content data to file.')
@@ -135,9 +136,9 @@ module ContentServer
           $remote_content_data_lock.synchronize{
             diff = ContentData.remove($local_content_data, $remote_content_data)
             unless diff.nil? || diff.empty?
-              Log.debug2("Backup content:\n#{$local_content_data}")
-              Log.debug2("Remote content:\n#{$remote_content_data}")
-              Log.debug2("Missing contents:\n#{diff}")
+              Log.debug2("Backup content:\n%s", $local_content_data)
+              Log.debug2("Remote content:\n%s", $remote_content_data)
+              Log.debug2("Missing contents:\n%s", diff)
               Log.info('Start sync check. Backup and remote contents need a sync, requesting copy files:')
               file_copy_client.request_copy(diff)
             else

data/lib/content_server/content_receiver.rb

@@ -14,15 +14,15 @@ module ContentServer
       Socket.tcp_server_loop(@port) do |sock, client_addrinfo|
         while size_of_data = sock.read(4)
           size_of_data = size_of_data.unpack("l")[0]
-          Log.debug2("Size of data: #{size_of_data}")
+          Log.debug2("Size of data: %s", size_of_data)
           data = sock.read(size_of_data)
           unmarshaled_data = Marshal.load(data)
           @queue.push unmarshaled_data
-          Log.debug2("Socket closed? #{sock.closed?}.")
+          Log.debug2("Socket closed? %s.", sock.closed?)
           break if sock.closed?
-          Log.debug2 'Waiting on sock.read'
+          Log.debug2('Waiting on sock.read')
         end
-        Log.debug2 'Exited, socket closed or read returned nil.'
+        Log.debug2('Exited, socket closed or read returned nil.')
       end
     end
   end
@@ -36,14 +36,14 @@ module ContentServer
     end
 
     def open_socket
-      Log.debug1("Connecting to content server #{@host}:#{@port}.")
+      Log.debug1("Connecting to content server %s:%s.", @host, @port)
       @tcp_socket = TCPSocket.new(@host, @port)
     end
 
     def send_content_data content_data
       open_socket if @tcp_socket.closed?
       marshal_data = Marshal.dump(content_data)
-      Log.debug2("Marshaled size: #{marshal_data.length}.")
+      Log.debug2("Marshaled size: %s.", marshal_data.length)
       data_size = [marshal_data.length].pack("l")
       if data_size.nil? || marshal_data.nil?
         Log.debug2('Send data is nil!!!!!!!!')

data/lib/content_server/content_server.rb

@@ -32,7 +32,7 @@ module ContentServer
     $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']}")
+      Log.info("Initializing monitoring of process params on port:%s", Params['process_monitoring_web_port'])
       $process_vars.set('server_name', 'content_server')
     end
 
@@ -40,9 +40,8 @@ module ContentServer
     # Initialize/Start monitoring
     Log.info('Start monitoring following directories:')
     Params['monitoring_paths'].each {|path|
-      Log.info("  Path:'#{path['path']}'")
+      Log.info("  Path:'%s'", path['path'])
     }
-    monitoring_events = Queue.new
 
     # initial global local content data object
     $local_content_data_lock = Mutex.new
@@ -50,19 +49,21 @@ module ContentServer
 
     # Read here for initial content data that exist from previous system run
     content_data_path = Params['local_content_data_path']
+    last_content_data_id = nil
     if File.exists?(content_data_path) and !File.directory?(content_data_path)
-      Log.info("reading initial content data that exist from previous system run from file:#{content_data_path}")
+      Log.info("reading initial content data that exist from previous system run from file:%s", content_data_path)
       $local_content_data.from_file(content_data_path)
+      last_content_data_id = $local_content_data.unique_id
     else
       if File.directory?(content_data_path)
-        raise("Param:'local_content_data_path':'#{Params['local_content_data_path']}'cannot be a directory name")
+        raise("Param:'local_content_data_path':'%s'cannot be a directory name", Params['local_content_data_path'])
       end
       # create directory if needed
       dir = File.dirname(Params['local_content_data_path'])
       FileUtils.mkdir_p(dir) unless File.exists?(dir)
     end
 
-    Log.info("Init monitoring")
+    Log.info('Init monitoring')
     monitoring_events = Queue.new
     fm = FileMonitoring::FileMonitoring.new()
     fm.set_event_queue(monitoring_events)
@@ -83,11 +84,10 @@ module ContentServer
     Log.debug1('Init thread: flush local content data to file')
     all_threads << Thread.new do
       FileUtils.mkdir_p(Params['tmp_path']) unless File.directory?(Params['tmp_path'])
-      last_content_data_id = nil
       loop{
         sleep(Params['data_flush_delay'])
         Log.info('Start flush local content data to file.')
-        $testing_memory_log.info('Start flush content data to file') if $testing_memory_log
+        $testing_memory_log.info('Start flush content data to file') if $testing_memory_active
         written_to_file = false
         $local_content_data_lock.synchronize{
           local_content_data_unique_id = $local_content_data.unique_id
@@ -96,11 +96,11 @@ module ContentServer
             $local_content_data.to_file($tmp_content_data_file)
             written_to_file = true
           else
-            Log.debug1('no need to flush. content data has not changed')
+            Log.info('no need to flush. content data has not changed')
           end
         }
         File.rename($tmp_content_data_file, Params['local_content_data_path']) if written_to_file
-        $testing_memory_log.info("End flush content data to file") if $testing_memory_log
+        $testing_memory_log.info("End flush content data to file") if $testing_memory_active
       }
     end
 

data/lib/content_server/file_streamer.rb

@@ -24,12 +24,12 @@ module ContentServer
 
     def self.close_delete_stream(checksum, streams_hash)
       if streams_hash.key?(checksum)
-        Log.debug1("close_delete_stream #{streams_hash[checksum].file}")
+        Log.debug1("close_delete_stream %s", streams_hash[checksum].path)
         begin
           streams_hash[checksum].file.close()
         rescue IOError => e
           Log.warning("While closing stream, could not close file #{streams_hash[checksum].path}." \
-                        " #{e.to_s}")
+                        " IOError msg:#{e.to_s}")
         end
         streams_hash.delete(checksum)
         $process_vars.set('Streams size', streams_hash.size)
@@ -105,7 +105,7 @@ module ContentServer
         checksum = content
         if @streams.key?(checksum)
           offset = @streams[checksum].file.pos
-          Log.debug1("Sending chunk for #{checksum}, offset #{offset}.")
+          Log.debug1("Sending chunk for %s, offset %s.",checksum, offset)
           chunk = @streams[checksum].file.read(Params['streaming_chunk_size'])
           if chunk.nil?
             # No more to read, send end of file.
@@ -116,7 +116,7 @@ module ContentServer
             @send_chunk_clb.call(checksum, offset, @streams[checksum].size, chunk, chunk_checksum)
           end
         else
-          Log.debug1("No checksum found to copy chunk. #{checksum}.")
+          Log.debug1("No stream found for copy chunk checksum %s.", checksum)
         end
       end
 
@@ -129,7 +129,7 @@ module ContentServer
           if offset > 0
             file.seek(offset)
           end
-          Log.debug1("File streamer: #{file.to_s}.")
+          Log.debug1("File streamer: %s.", file)
           @streams[checksum] = Stream.new(checksum, path, file, file.size)
           $process_vars.set('Streams size', @streams.size)
         rescue IOError, Errno::ENOENT => e
@@ -223,13 +223,15 @@ module ContentServer
     def handle_new_chunk(file_checksum, offset, content)
       if offset == @streams[file_checksum].file.pos
         FileReceiver.write_string_to_file(content, @streams[file_checksum].file)
-        Log.debug1("Written already #{@streams[file_checksum].file.pos} bytes, " \
-                 "out of #{@streams[file_checksum].size} " \
-                 "(#{100.0*@streams[file_checksum].file.size/@streams[file_checksum].size}%)")
+        if Params['log_debug_level'] >= 1  # added the condition here to avoid calculations
+          Log.debug1("Written already %s bytes, out of %s (%s%%)",
+                     @streams[file_checksum].file.pos, @streams[file_checksum].size,
+                    100.0*@streams[file_checksum].file.size/@streams[file_checksum].size)
+        end
         return true
       else
         # Offset is wrong, send reset/resume copy from correct offset.
-        Log.warning("Received chunk with incorrect offset #{offset}, should " \
+        Log.warning("Received chunk with incorrect offset #{offset}, should " + \
                       "be #{@streams[file_checksum].file.pos}, file_checksum:#{file_checksum}")
         @reset_copy.call(file_checksum, @streams[file_checksum].file.pos) unless @reset_copy.nil?
         return false
@@ -246,7 +248,7 @@ module ContentServer
         # Make the directory if does not exists.
         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("Moving tmp file %s to %s", @streams[file_checksum].path, path)
         file_dir = File.dirname(path)
         FileUtils.makedirs(file_dir) unless File.directory?(file_dir)
         # Move tmp file to permanent location.
@@ -259,7 +261,7 @@ module ContentServer
           Log.debug1(message)
           begin
             File.rename(tmp_file_path, path)
-            Log.debug1("End move tmp file to permanent location #{path}.")
+            Log.debug1("End move tmp file to permanent location %s.", path)
             @file_done_clb.call(local_file_checksum, path) unless @file_done_clb.nil?
           rescue Exception => e
             Log.warning("Could not move tmp file to permanent path #{path}." +
@@ -268,7 +270,7 @@ module ContentServer
         else
           begin
             Log.error(message)
-            Log.debug1("Deleting tmp file: #{tmp_file_path}")
+            Log.debug1("Deleting tmp file: %s", tmp_file_path)
             File.delete(tmp_file_path)
           rescue Exception => e
             Log.warning("Could not delete tmp file from tmp path #{tmp_file_path}." +
@@ -282,7 +284,7 @@ module ContentServer
 
     def self.write_string_to_file(str, file)
       bytes_to_write = str.bytesize
-      Log.debug1("writing to file: #{file.to_s}, #{bytes_to_write} bytes.")
+      Log.debug1("writing to file: %s, %s bytes.", file, bytes_to_write)
       while bytes_to_write > 0
         bytes_to_write -= file.write(str)
       end

data/lib/content_server/queue_copy.rb

@@ -36,7 +36,7 @@ module ContentServer
     # Add content to copy process. If already in copy process or waiting for copy then skip.
     # If no open places for copy then put in waiting list
     def add_content(checksum, path)
-      Log.debug2("Try to add content:#{checksum} to copy waiting list")
+      Log.debug2("Try to add content:%s to copy waiting list", checksum)
       @keeper.synchronize{
         # if content is being copied or waiting then skip it
         if !@contents_under_copy[checksum]
@@ -48,16 +48,16 @@ module ContentServer
               $process_vars.set('Copy File Queue Size', @copy_input_queue.size)
             else
               # no place in copy streams. Add to waiting list
-              Log.debug2("add content:#{checksum} to copy waiting list")
+              Log.debug2("add content:%s to copy waiting list", checksum)
               @contents_to_copy[checksum] = true  # replace with a set
               @contents_to_copy_queue.push([checksum, path])
               $process_vars.set('contents to copy queue', @contents_to_copy_queue.size)
             end
           else
-            Log.debug2("content:#{checksum} already in waiting list. skipping.")
+            Log.debug2("content:%s already in waiting list. skipping.", checksum)
           end
         else
-          Log.debug2("content:#{checksum} is being copied. skipping.")
+          Log.debug2("content:%s is being copied. skipping.", checksum)
         end
       }
     end
@@ -68,22 +68,22 @@ module ContentServer
         if content_record
           if !content_record[1]
             path = content_record[0]
-            Log.debug1("Streaming to backup server. content: #{checksum} path:#{path}.")
+            Log.debug1("Streaming to backup server. content: %s path:%s.", checksum, path)
             @file_streamer.start_streaming(checksum, path)
             # updating Ack
             content_record[1] = true
           else
-            Log.warning("File already received ack: #{checksum}")
+            Log.warning("File already received ack: %s", checksum)
           end
         else
-          Log.warning("File was aborted or copied: #{checksum}")
+          Log.warning("File was aborted or copied: %s", checksum)
         end
       }
     end
 
     def remove_content(checksum)
       @keeper.synchronize{
-        Log.debug3("removing checksum:#{checksum} from contents under copy")
+        Log.debug3("removing checksum:%s from contents under copy", checksum)
         @contents_under_copy.delete(checksum)
         $process_vars.set('contents under copy', @contents_under_copy.size)
         #1 place is became available. Put another file in copy process if waiting
@@ -146,7 +146,7 @@ module ContentServer
       # resend the ack request.
       @copy_prepare = {}
       @file_streamer = FileStreamer.new(method(:send_chunk))
-      Log.debug3("initialize FileCopyServer on port:#{port}")
+      Log.debug3("initialize FileCopyServer on port:%s", port)
       @file_copy_manager = FileCopyManager.new(@copy_input_queue, @file_streamer)
     end
 
@@ -157,7 +157,7 @@ module ContentServer
 
     def receive_message(addr_info, message)
       # Add ack message to copy queue.
-      Log.debug2("Content server Copy message received: #{message}")
+      Log.debug2("Content server Copy message received: %s", message)
       @copy_input_queue.push(message)
       $process_vars.set('Copy File Queue Size', @copy_input_queue.size)
     end
@@ -170,10 +170,10 @@ module ContentServer
           Log.debug1 'Waiting on copy files events.'
           (message_type, message_content) = @copy_input_queue.pop
           $process_vars.set('Copy File Queue Size', @copy_input_queue.size)
-          Log.debug1("Content copy message:#{[message_type, message_content]}")
+          Log.debug1("Content copy message:Type:%s  content:%s", message_type, message_content)
 
           if message_type == :SEND_ACK_MESSAGE
-            Log.debug1("Sending ack for: #{message_content}")
+            Log.debug1("Sending ack for: %s", message_content)
             @backup_tcp.send_obj([:ACK_MESSAGE, [message_content, Time.now.to_i]])
           elsif message_type == :COPY_MESSAGE
             message_content.each_instance { |checksum, size, content_mod_time, instance_mod_time, server, path|
@@ -184,7 +184,7 @@ module ContentServer
             # The timestamp is of local content server! not backup server!
             timestamp, ack, checksum = message_content
             Log.debug1("Ack (#{ack}) received for content: #{checksum}, timestamp: #{timestamp} " \
-                       "now: #{Time.now.to_i}")
+                       "now: #{Time.now.to_i}") if Params['log_debug_level'] >= 1  # adding to avoid Time.now
 
             # Copy file if ack (does not exists on backup and not too much time passed)
             if ack
@@ -192,7 +192,7 @@ module ContentServer
                 @file_copy_manager.receive_ack(checksum)
               else
                 Log.debug1("Ack timed out span: #{Time.now.to_i - timestamp} > " \
-                           "timeout: #{Params['ack_timeout']}")
+                  "timeout: #{Params['ack_timeout']}") if Params['log_debug_level'] >= 1  # adding to avoid Time.now
                 # remove only content under copy
                 @file_copy_manager.remove_content(checksum)
               end
@@ -207,8 +207,9 @@ module ContentServer
           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}, checksum:#{content_checksum}")
+            Log.debug1("Send chunk for file %s, offset: %s " \
+                         "filesize: %s, checksum: %s",
+                       file_checksum, offset, file_size, content_checksum)
             # Blocking send.
             @backup_tcp.send_obj([:COPY_CHUNK, message_content])
             if content.nil? and content_checksum.nil?
@@ -216,13 +217,14 @@ module ContentServer
               @file_copy_manager.remove_content(file_checksum)
             end
           elsif message_type == :ABORT_COPY
-            Log.debug1("Aborting file copy: #{message_content}")
+            Log.debug1("Aborting file copy: %s", message_content)
             @file_streamer.abort_streaming(message_content)
             # remove only content under copy
             @file_copy_manager.remove_content(message_content)
           elsif message_type == :RESET_RESUME_COPY
             (file_checksum, new_offset) = message_content
-            Log.debug1("Resetting/Resuming file (#{file_checksum}) copy to #{new_offset}")
+            Log.debug1("Resetting/Resuming file (%s) copy to %s",
+                       file_checksum, new_offset)
             @file_streamer.reset_streaming(file_checksum, new_offset)
           else
             Log.error("Copy event not supported: #{message_type}")
@@ -248,7 +250,7 @@ module ContentServer
         end
       end
       @local_thread.abort_on_exception = true
-      Log.debug3("initialize FileCopyClient  host:#{host}  port:#{port}")
+      Log.debug3("initialize FileCopyClient  host:%s  port:%s", host, port)
     end
 
     def threads
@@ -271,7 +273,7 @@ module ContentServer
 
     def done_copy(local_file_checksum, local_path)
       $process_vars.inc('num_files_received')
-      Log.debug1("Done copy file: #{local_path}, #{local_file_checksum}")
+      Log.debug1("Done copy file: path %s, checksum %s", local_path, local_file_checksum)
     end
 
     def handle_message(message)
@@ -284,10 +286,10 @@ module ContentServer
     # of ack. Note that it is being executed from the class thread only!
     def handle(message)
       message_type, message_content = message
-      Log.debug1("backup copy message: Type #{message_type}.  message: #{message_content}")
+      Log.debug1("backup copy message: Type %s. message: %s", message_type, message_content)
       if message_type == :SEND_COPY_MESSAGE
         bytes_written = @tcp_client.send_obj([:COPY_MESSAGE, message_content])
-        Log.debug2("Sending copy message succeeded? bytes_written: #{bytes_written}.")
+        Log.debug2("Sending copy message succeeded? bytes_written: %s.", bytes_written)
       elsif message_type == :COPY_CHUNK
         if @file_receiver.receive_chunk(*message_content)
           file_checksum, offset, file_size, content, content_checksum = message_content
@@ -301,7 +303,7 @@ module ContentServer
         # check if checksum exists in final destination
         dest_path = FileReceiver.destination_filename(Params['backup_destination_folder'][0]['path'], checksum)
         need_to_copy = !File.exists?(dest_path)
-        Log.debug1("Returning ack for content:'#{checksum}' timestamp:'#{timestamp}' Ack:'#{need_to_copy}'")
+        Log.debug1("Returning ack for content:'%s' timestamp:'%s' Ack:'%s'", checksum, timestamp, need_to_copy)
         @tcp_client.send_obj([:ACK_MESSAGE, [timestamp,
                                              need_to_copy,
                                              checksum]])