Class: Rseed::Processor

Inherits:
Object
  • Object
show all
Defined in:
lib/rseed/processor.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Processor

Returns a new instance of Processor.



7
8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/rseed/processor.rb', line 7

def initialize(options = {})
  return nil unless options[:adapter]
  return nil unless options[:converter]

  self.logger = options[:logger] unless options[:logger].nil?
  adapter = options[:adapter].is_a?(Adapter) ? options[:adapter] : Rseed.const_get("#{options[:adapter].to_s.classify}Adapter").new
  converter = options[:converter].is_a?(Converter) ? options[:converter] : Rseed.const_get("#{options[:converter].to_s.classify}Converter").new
  converter.options = deserialize_options(options[:converter_options])if options[:converter_options]
  adapter.options = deserialize_options(options[:adapter_options])if options[:adapter_options]
  @within_transaction = options[:within_transaction]
  @adapter = adapter
  @converter = converter
end

Instance Attribute Details

#adapter ⇒ Object (readonly)

Returns the value of attribute adapter.



4
5
6
 
# File 'lib/rseed/processor.rb', line 4

def adapter
  @adapter
end

#converter ⇒ Object (readonly)

Returns the value of attribute converter.



5
6
7
 
# File 'lib/rseed/processor.rb', line 5

def converter
  @converter
end

#logger ⇒ Object 



21
22
23
 
# File 'lib/rseed/processor.rb', line 21

def logger
  @logger.nil? ? Rseed.logger : @logger
end

Instance Method Details

#deserialize(options = {}) {|:complete, {success: true}, {total_records: total_records, record_count: record_count}| ... } ⇒ Object

Yields:

  • (:complete, {success: true}, {total_records: total_records, record_count: record_count}) 


25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/rseed/processor.rb', line 25

def deserialize options = {}, &block
  total_records = 0
  record_count = 0

  converter.logger = logger
  adapter.logger = logger
  adapter.converter = converter

  begin
    logger.info "Converter: #{@converter.name.cyan}"
    logger.info "Converter Options: #{@converter.options.to_s.dup.cyan}"
    yield :preprocessing
    if @adapter.preprocess
      if @converter.before_deserialize
        yield :processing
        start_time = Time.now
        wrap_inserts do
          adapter.process do |values, meta|
            result = {values: values}
            meta ||= {}
            begin
              if @converter.deserialize_raw(values)
                result[:success] = true
              else
                result[:success] = false
                result[:message] = "Failed to convert"
                result[:error] = @converter.error
              end
            rescue => e
              result[:success] = false
              result[:message] = "Exception during deserialize"
              result[:error] = e.message
              result[:backtrace] = e.backtrace
            end

            total_records = meta[:total_records] unless meta[:total_records].nil?
            record_count = meta[:record_count] unless meta[:record_count].nil?
            # Calculate the ETA
            if record_count and total_records
              remaining = total_records - record_count
              tpr = (Time.now - start_time)/record_count
              meta[:eta] = remaining * tpr
            end

            # Log any errors
            unless result[:success]
              logger.error result[:message].to_s.red
              logger.error result[:error].to_s.red
              logger.error meta.to_s.cyan
              logger.error result[:backtrace].to_s unless result[:backtrace].to_s.blank?
            end
            yield :processing, result, meta
          end
          @converter.after_deserialize
        end
      else
        yield :error, {success: false, message: 'Before deserialize failed', error: @converter.error}
      end
    else
      yield :error, {success: false, message: 'Preprocessing failed', error: @adapter.error}
    end
  rescue => e
    yield :error, {success: false, message: 'Exception during Processing', error: e.message, backtrace: e.backtrace}
  end
  yield :complete, {success: true}, {total_records: total_records, record_count: record_count}
end