Class: MadCat::LitterBox

Inherits:

Object

• Object
• MadCat::LitterBox

Defined in:

lib/madcat.rb

Defined Under Namespace

Classes: ErrorFromJSON, MalformedInput, MalformedOutput, NonZeroExit, PipelineStop

Instance Method Summary

• #initialize(logger) ⇒ LitterBox constructor

  A new instance of LitterBox.

• #l ⇒ Object
• #run(blob, id = :unknown, trace = false, depth = 0, meta_in = nil, meta_key = nil) ⇒ Object

Constructor Details

#initialize(logger) ⇒ LitterBox

Returns a new instance of LitterBox.

# File 'lib/madcat.rb', line 209

def initialize(logger)
  @logger = logger
end

Instance Method Details

#l ⇒ Object

# File 'lib/madcat.rb', line 341

def l
  @logger
end

#run(blob, id = :unknown, trace = false, depth = 0, meta_in = nil, meta_key = nil) ⇒ Object

# File 'lib/madcat.rb', line 213

def run(blob, id=:unknown, trace=false, depth=0, meta_in=nil, meta_key=nil)
  begin
    # scaffold the results-object as early as possible
    # because this will also be returned and augmented
    # when an exception occurs.
    results = [{'id' => id, :exit => -1, :stdin => blob,
                'duration' => -1, :stdout => '', :stderr => ''}]

    blob = JSON.parse(blob)

    meta = Marshal.load(Marshal.dump(meta_in)) # deep_copy

    todo = meta['todo']
    raise RuntimeError, 'Pipeline has no jobs defined?!' if todo.length == 0

    pipeline_id = meta['id']
    job = todo.shift
    cmd = job.split(' ')
    job = cmd[0]

    # find our executable
    bin_path = meta['path']
    bin = nil
    bin_path.each do |e|
      bin = File.join(e, cmd[0])
      break if File.executable? bin
      bin = nil
    end

    if bin.nil?
      raise RuntimeError, "Executable #{job} not found in #{bin_path.join(':')}"
    end

    # update meta
    meta['current'] = job

    # add read-only metadata
    if meta_key
      blob[meta_key] = meta
    end

  
    # run our executable
    blob['*'] = cmd[0]
    stdin = blob.to_json
    results[0][:stdin] = stdin # we modified it above
    start_time = Time.now
    p = MadCat::Helpers::exec!([bin] + cmd[1..-1], stdin)
    duration = (Time.now - start_time).to_f
    results[0].merge!({:bin => bin, :exit => p.status, 'duration' => duration,
                       :stdout => p.stdout, :stderr => p.stderr, :todo => todo,
                       :depth => depth })

    if trace
      d=0
      meta['done'].each do |node|
        l.debug "## #{'  ' * d}#{node.keys[0]}"
        d+=1
      end
      l.debug "## #{'  ' * d}#{id} <--"

      l.debug "#" * 70
      # zomg HACK: append a newline to stdin/stdout/stderr to convince
      # the yaml serializer to print them as block literals.
      # a bit evil, but it makes the trace-output much more readable...
      [:stdin, :stdout, :stderr].each do |key|
        if 0 < results[0][key].length && results[0][key][-1] != "\n"
          results[0][key] += "\n"
        end
      end

      results[0].to_yaml.split("\n").each do |line|
        next if line[0..2] == '---'
        l.debug line
      end
      l.debug "#" * 70
    end
 
    # alert on exit code != 0
    raise NonZeroExit, "#{p.status}" if p.status != 0

    # no output?  game over.
    raise PipelineStop if p.stdout == ''

    # parse output and wrap JSON errors
    begin
      blobs = JSON.parse(p.stdout)
    rescue => e
      raise MalformedOutput, "Could not parse JSON: #{e.message}" if 0 < todo.length
    end
    blobs = [blobs] unless blobs.is_a? Array

    # raise on json-key 'err'
    blobs.each do |blob|
      if blob.include? 'err'
        raise ErrorFromJSON, blob['err']
      end
    end

    # oob mode
    meta['done'] << { results[-1]['id'] => results[-1].select{|k,v| ['duration', :exit].include? k} }

    # feed blob to next stage of the pipeline
    i=0
    blobs.each do |new_inner_blob|
      break if 0 == todo.length 

      # store output blob under jobid
      blob_ = Marshal.load(Marshal.dump(blob)) # deep_copy
      blob_[job] ||= {}
      blob_[job].deep_merge! new_inner_blob

      got = run(blob_.to_json, "#{todo[0].split(' ')[0]}:#{i}", trace, depth+1, meta, meta_key)
      results += got

      i+=1
    end
    results
  rescue => e
    results[-1][:exception_type] = e.class.name.split('::')[-1]
    results[-1][:exception_message] = e.message
    results[-1][:exception_backtrace] = e.backtrace

    # bubble up
    results
  end
end