rest-ftp-daemon 0.72b → 0.85.2

data/lib/rest-ftp-daemon/job.rb

@@ -3,31 +3,37 @@
 require 'uri'
 require 'net/ftp'
 require 'double_bag_ftps'
+require 'timeout'
 
 module RestFtpDaemon
   class Job < RestFtpDaemon::Common
+    attr_accessor :wid
 
     def initialize(id, params={})
       # Call super
-      super()
+      # super()
+      info "Job.initialize"
 
-      # Grab params
-      @params = params
+      # Generate new Job.id
+      # $queue.counter_add :transferred, source_size
+
+      # Logger
+      @logger = RestFtpDaemon::Logger.new(:workers, "JOB #{id}")
+
+      # Protect with a mutex
+      @mutex = Mutex.new
 
       # Init context
+      @params = params
       set :id, id
       set :started_at, Time.now
-      set :status, :created
+      status :created
 
       # Send first notification
+      info "Job.initialize/notify"
       notify "rftpd.queued"
     end
 
-    def progname
-      job_id = get(:id)
-      "JOB #{job_id}"
-    end
-
     def id
       get :id
     end
@@ -40,60 +46,99 @@ module RestFtpDaemon
     end
 
     def process
-      # Init
-      info "Job.process starting"
-      set :status, :starting
-      set :error, 0
+      # Update job's status
+      set :error, nil
 
+      # Prepare job
       begin
-        # Validate job and params
+        info "Job.process/prepare"
+        status :preparing
         prepare
 
-        # Process
+      rescue RestFtpDaemon::JobMissingAttribute => exception
+        return oops "rftpd.started", exception, :job_missing_attribute
+
+      rescue RestFtpDaemon::JobSourceNotFound => exception
+        return oops "rftpd.started", exception, :job_source_not_found
+
+      rescue RestFtpDaemon::RestFtpDaemonException => exception
+        return oops "rftpd.started", exception, :job_prepare_failed
+
+      rescue Exception => exception
+        return oops "rftpd.started", exception, :job_prepare_unhandled, true
+
+      rescue exception
+        return oops "rftpd.started", exception, :WOUHOU, true
+
+      else
+        # Update job's status
+        info "Job.process/prepare ok"
+        status :prepared
+        info "Job.process/prepare status updated"
+
+        # Notify rftpd.start
+        info "Job.process/prepare notify started"
+        notify "rftpd.started", 0
+        info "Job.process/prepare notified started"
+      end
+
+      info "Job.process prepare>transfer"
+
+      # Process job
+      begin
+        info "Job.process/transfer"
+        status :starting
         transfer
 
+      rescue Timeout::Error => exception
+        return oops "rftpd.ended", exception, :job_timeout_error
+
       rescue Net::FTPPermError => exception
-        info "Job.process failed [Net::FTPPermError]"
-        set :status, :failed
-        set :error, exception.class
+        return oops "rftpd.ended", exception, :job_ftp_perm_error
+
+      rescue Errno::ECONNREFUSED => exception
+        return oops "rftpd.ended", exception, :job_connexion_refused
+
+      rescue Errno::EMFILE => exception
+        return oops "rftpd.ended", exception, :job_too_many_open_files
+
+      rescue RestFtpDaemon::JobTargetFileExists => exception
+        return oops "rftpd.ended", exception, :job_target_file_exists
 
-      rescue RestFtpDaemonException => exception
-        info "Job.process failed [::#{exception.class}]"
-        set :status, :failed
-        set :error, exception.class
+      rescue RestFtpDaemon::RestFtpDaemonException => exception
+        return oops "rftpd.ended", exception, :job_transfer_failed
 
       rescue Exception => exception
-        info "Job.process exception [#{exception.class}] #{exception.backtrace.inspect}"
-        set :status, :crashed
-        set :error, exception.class
+        return oops "rftpd.ended", exception, :job_transfer_unhandled, true
 
       else
+        # Update job's status
         info "Job.process finished"
-        set :status, :finished
+        status :finished
+
+        # Notify rftpd.ended
+        notify "rftpd.ended", 0
       end
 
     end
 
     def describe
-      # Update realtime info
-      #w = wandering_time
-      #set :wandering, w.round(2) unless w.nil?
-
       # Update realtime info
       u = up_time
       set :uptime, u.round(2) unless u.nil?
 
-      # Return the whole structure
+      # Return the whole structure  FIXME
       @params
-    end
-
-    def status text
-      @status = text
+      # @mutex.synchronize do
+      #   out = @params.clone
+      # end
     end
 
     def get attribute
-      return nil unless @params.is_a? Enumerable
-      @params[attribute.to_s]
+      @mutex.synchronize do
+        @params || {}
+        @params[attribute]
+      end
     end
 
   protected
@@ -116,15 +161,17 @@ module RestFtpDaemon
       @wander_for.to_f - (Time.now - @wander_started)
     end
 
-    # def exception_handler(actor, reason)
-    #   set :status, :crashed
-    #   set :error, reason
-    # end
-
     def set attribute, value
-      return unless @params.is_a? Enumerable
-      @params[:updated_at] = Time.now
-      @params[attribute.to_s] = value
+      @mutex.synchronize do
+        @params || {}
+        # return unless @params.is_a? Enumerable
+        @params[:updated_at] = Time.now
+        @params[attribute] = value
+      end
+    end
+
+    def status status
+      set :status, status
     end
 
     def expand_path path
@@ -138,169 +185,246 @@ module RestFtpDaemon
     def replace_token path
       # Ensure endpoints are not a nil value
       return path unless Settings.endpoints.is_a? Enumerable
-      newpath = path.clone
+      vectors = Settings.endpoints.clone
+
+      # Stack RANDOM into tokens
+      vectors['RANDOM'] = SecureRandom.hex(IDENT_RANDOM_LEN)
 
       # Replace endpoints defined in config
-      Settings.endpoints.each do |from, to|
-        newpath.gsub! "[#{from}]", to
+      newpath = path.clone
+      vectors.each do |from, to|
+        next if to.to_s.blank?
+        #info "Job.replace_token #{Helpers.tokenize(from)} > #{to}"
+        newpath.gsub! Helpers.tokenize(from), to
       end
 
-      # Replace with the special RAND token
-      newpath.gsub! "[RANDOM]", SecureRandom.hex(8)
-
       return newpath
     end
 
     def prepare
       # Init
-      info "Job.prepare"
-      set :status, :preparing
+      status :preparing
       @source_method = :file
       @target_method = nil
       @source_path = nil
       @target_url = nil
 
       # Check source
-      raise JobSourceMissing unless @params["source"]
-      #@source = expand_path @params["source"]
-      @source_path = expand_path @params["source"]
+      raise RestFtpDaemon::JobMissingAttribute unless @params[:source]
+      @source_path = expand_path @params[:source]
       set :source_path, @source_path
       set :source_method, :file
 
       # Check target
-      raise JobTargetMissing unless @params["target"]
-      @target_url = expand_url @params["target"]
-      set :target_url, @target_url.inspect
+      raise RestFtpDaemon::JobMissingAttribute unless @params[:target]
+      @target_url = expand_url @params[:target]
+      set :target_url, @target_url.to_s
 
       if @target_url.kind_of? URI::FTP
         @target_method = :ftp
+      elsif @target_url.kind_of? URI::FTPES
+        @target_method = :ftps
       elsif @target_url.kind_of? URI::FTPS
         @target_method = :ftps
       end
       set :target_method, @target_method
 
       # Check compliance
-      raise JobTargetUnparseable if @target_url.nil?
-      raise JobTargetUnsupported if @target_method.nil?
-      raise JobSourceNotFound unless File.exists? @source_path
-
+      raise RestFtpDaemon::JobTargetUnparseable if @target_url.nil?
+      raise RestFtpDaemon::JobTargetUnsupported if @target_method.nil?
+      raise RestFtpDaemon::JobSourceNotFound unless File.exists? @source_path
     end
 
-    def transfer_fake
+    def transfer
+      # Method assertions
+      info "Job.transfer checking_source"
+      status :checking_source
+      raise RestFtpDaemon::JobAssertionFailed unless @source_path &&  @target_url
+
       # Init
-      set :status, :faking
 
-      # Work
-      (0..9).each do |i|
-        set :faking, i
-        sleep 0.5
+      target_name = File.basename @target_url.path
+
+      # Scheme-aware config
+      ftp_init
+
+      # Connect remote server, login and chdir
+      ftp_connect
+
+      # Check for target file presence
+      if get(:overwrite).nil? && (ftp_presence target_name)
+        @ftp.close
+        raise RestFtpDaemon::JobTargetFileExists
       end
-    end
 
-    def transfer
-      # Init
-      info "Job.transfer"
+      # Do transfer
+      ftp_transfer target_name
 
-      # Send first notification
-      transferred = 0
-      notify "rftpd.started"
+      # Close FTP connexion
+      info "Job.transfer disconnecting"
+      status :disconnecting
+      @ftp.close
+    end
 
-      # Ensure @source and @target are there
-      info "Job.transfer checking_source"
-      set :status, :checking_source
-      raise RestFtpDaemon::JobPrerequisitesNotMet unless @source_path
-      raise RestFtpDaemon::JobPrerequisitesNotMet unless @target_url
-      target_path = File.dirname @target_url.path
-      target_name = File.basename @target_url.path
+  private
 
-      # Read source file size
-      source_size = File.size @source_path
-      set :file_size, source_size
+    def oops signal_name, exception, error_name = nil, include_backtrace = false
+      # Log this error
+      error_name = exception.class if error_name.nil?
+      info "Job.oops si[#{signal_name}] er[#{error_name.to_s}] ex[#{exception.class}]"
+
+      # Update job's internal status
+      set :status, :failed
+      set :error, error_name
+      set :error_exception, exception.class
+
+      # Build status stack
+      status = nil
+      if include_backtrace
+        set :error_backtrace, exception.backtrace
+        status = {
+          backtrace: exception.backtrace,
+        }
+      end
 
-      # Prepare FTP transfer
-      info "Job.transfer preparing"
+      # Prepare notification if signal given
+      return unless signal_name
+      notify signal_name, error_name, status
+    end
+
+    def ftp_init
+      # Method assertions
+      info "Job.ftp_init"
+      status :ftp_init
+      raise RestFtpDaemon::JobAssertionFailed if @target_method.nil? || @target_url.nil?
 
-      # Scheme-aware config
       case @target_method
       when :ftp
-        info "Job.transfer scheme FTP"
-        ftp = Net::FTP.new
+        info "Job.ftp_init scheme: ftp"
+        @ftp = Net::FTP.new
       when :ftps
-        info "Job.transfer scheme FTPS"
-        ftp = DoubleBagFTPS.new
-        ftp.ssl_context = DoubleBagFTPS.create_ssl_context(:verify_mode => OpenSSL::SSL::VERIFY_NONE)
-        ftp.ftps_mode = DoubleBagFTPS::EXPLICIT
+        info "Job.transfer scheme: ftps"
+        @ftp = DoubleBagFTPS.new
+        @ftp.ssl_context = DoubleBagFTPS.create_ssl_context(:verify_mode => OpenSSL::SSL::VERIFY_NONE)
+        @ftp.ftps_mode = DoubleBagFTPS::EXPLICIT
       else
-        info "Job.transfer scheme other: [#{@target_url.scheme}]"
+        info "Job.transfer scheme: other [#{@target_url.scheme}]"
       end
+    end
 
-      # Connect remote server
-      info "Job.transfer connecting"
-      set :status, :connecting
-      ftp.connect(@target_url.host)
-      ftp.passive = true
+    def ftp_connect
+      #status :ftp_connect
+      # connect_timeout_sec = (Settings.transfer.connect_timeout_sec rescue nil) || DEFAULT_CONNECT_TIMEOUT_SEC
 
-      # Logging in
-      info "Job.transfer login"
-      begin
-        u = ftp.login @target_url.user, @target_url.password
-      rescue Exception => exception
-        info "Job.process login failed [#{exception.class}] #{u.inspect}"
-        set :status, :login_failed
-        set :error, exception.class
-      end
+      # Method assertions
+      info "Job.ftp_connect connect"
+      status :ftp_connect
+      raise RestFtpDaemon::JobAssertionFailed if @ftp.nil? || @target_url.nil?
 
-      # Changing to directory
-      info "Job.transfer chdir"
-      set :status, :chdir
-      ftp.chdir(target_path)
+        ret = @ftp.connect(@target_url.host)
+        @ftp.passive = true
 
-      # Check for target file presence
-      if get(:overwrite).nil?
-        info "Job.transfer remote_check (#{target_name})"
-        set :status, :remote_check
-
-        # Get file list, sometimes the response can be an empty value
-        results = ftp.list(target_name) rescue nil
-
-        # Result can be nil or a list of files
-        if results.nil? || results.count.zero?
-          info "Job.transfer remote_absent"
-          set :status, :remote_absent
-        else
-          info "Job.transfer remote_present"
-          set :status, :remote_present
-          ftp.close
-          notify "rftpd.ended", RestFtpDaemon::JobTargetFileExists
-          raise RestFtpDaemon::JobTargetFileExists
-        end
+      info "Job.ftp_connect login"
+      status :ftp_login
+      ret = @ftp.login @target_url.user, @target_url.password
 
-      end
+      info "Job.ftp_connect chdir"
+      status :ftp_chdir
+      path = File.dirname @target_url.path
+      ret = @ftp.chdir(path)
+    end
 
-      # Do transfer
-      info "Job.transfer uploading"
-      set :status, :uploading
-      chunk_size = Settings.transfer.chunk_size || Settings[:default_chunk_size]
-      notify_size = Settings.transfer.chunk_size || Settings[:default_notify_size]
-      ftp.putbinaryfile(@source_path, target_name, chunk_size) do |block|
+    def ftp_presence target_name
+      # Method assertions
+      info "Job.ftp_presence"
+      status :ftp_presence
+      raise RestFtpDaemon::JobAssertionFailed if @ftp.nil? || @target_url.nil?
+
+      # Get file list, sometimes the response can be an empty value
+      results = @ftp.list(target_name) rescue nil
+
+      # Result can be nil or a list of files
+      return false if results.nil?
+      return results.count >0
+    end
+
+    def ftp_transfer target_name
+      # Method assertions
+      info "Job.ftp_transfer starting"
+      status :ftp_transfer
+      raise RestFtpDaemon::JobAssertionFailed if @ftp.nil? || @source_path.nil?
+
+      # Read source file size and parameters
+      source_size = File.size @source_path
+      set :transfer_size, source_size
+      update_every_kb = (Settings.transfer.update_every_kb rescue nil) || DEFAULT_UPDATE_EVERY_KB
+      notify_after_sec = Settings.transfer.notify_after_sec rescue nil
+
+      # Start transfer
+      transferred = 0
+      chunk_size = update_every_kb * 1024
+      t0 = tstart = Time.now
+      notified_at = Time.now
+      status :uploading
+      @ftp.putbinaryfile(@source_path, target_name, chunk_size) do |block|
         # Update counters
         transferred += block.bytesize
+        set :transfer_sent, transferred
+
+        # Update bitrate
+        dt = Time.now - t0
+        bitrate0 = (8 * chunk_size/dt).round(0)
+        set :transfer_bitrate, bitrate0
 
         # Update job info
-        percent = (100.0 * transferred / source_size).round(1)
-        set :progress, percent
-        set :file_sent, transferred
+        percent1 = (100.0 * transferred / source_size).round(1)
+        set :progress, percent1
+
+        # Log progress
+        status = []
+        status << "#{percent1} %"
+        status << (Helpers.format_bytes transferred, "B")
+        status << (Helpers.format_bytes source_size, "B")
+        status << (Helpers.format_bytes bitrate0, "bps")
+        info "Job.ftp_transfer" + status.map{|txt| ("%#{DEFAULT_LOGS_PROGNAME_TRIM.to_i}s" % txt)}.join("\t")
+
+        # Update time pointer
+        t0 = Time.now
+
+        # Notify if requested
+        unless notify_after_sec.nil? || (notified_at + notify_after_sec > Time.now)
+          status = {
+            progress: percent1,
+            transfer_sent: transferred,
+            transfer_size: source_size,
+            transfer_bitrate: bitrate0
+            }
+          notify "rftpd.progress", 0, status
+          notified_at = Time.now
+        end
+
       end
 
-      # Close FTP connexion
-      info "Job.transfer closing"
-      set :status, :disconnecting
-      notify "rftpd.ended"
-      set :progress, nil
-      ftp.close
+      # Compute final bitrate
+      tbitrate0 = (8 * source_size.to_f / (Time.now - tstart)).round(0)
+      set :transfer_bitrate, tbitrate0
+
+      # Add total transferred to counter
+      $queue.counter_add :transferred, source_size
+
+      # Done
+      #set :progress, nil
+      info "Job.ftp_transfer finished"
     end
 
-  private
+    def notify signal, error = 0, status = {}
+      RestFtpDaemon::Notification.new get(:notify), {
+        id: get(:id),
+        signal: signal,
+        error: error,
+        status: status,
+        }
+    end
 
   end
 end