scout-gear 9.1.0 → 10.0.1

data/lib/scout/config.rb

@@ -1,168 +0,0 @@
-require_relative 'path'
-require_relative 'resource'
-require_relative 'resource/scout'
-
-module Scout::Config
-
-  CACHE ||= IndiferentHash.setup({})
-
-  GOT_KEYS=[]
-
-  def self.add_entry(key, value, tokens)
-    tokens = [tokens] unless Array === tokens
-    tokens << "key:#{key}" unless tokens.include?("key:#{key}")
-    CACHE[key.to_s] ||= [] 
-    CACHE[key.to_s] << [tokens, value]
-  end
-
-  def self.load_file(file)
-    Log.debug "Loading config file: #{ file }"
-    TSV.traverse file, :type => :array do |line|
-      next if line =~ /^#/
-      key, value, *tokens = line.strip.split(/\s/)
-
-      self.add_entry(key, value, tokens) if key
-    end
-  end
-
-  def self.load_config
-    Scout.etc.config.find_all.reverse.each do |file|
-      self.load_file(file)
-    end
-  end
-
-  def self.set(values, *tokens)
-    if not Hash === values
-      values = {values => tokens.shift}
-    end
-
-    values.each do |key,value|
-      add_entry key, value, tokens
-    end
-  end
-
-  def self.token_priority(token)
-    token, _sep, priority = token.to_s.partition("::")
-
-    if priority.nil? || priority.empty?
-      type, _sep, rest = token.partition(":")
-      priority = case type
-                 when "workflow"
-                   4
-                 when "task"
-                   3
-                 when "file"
-                   2
-                 when "line"
-                   1
-                 when "key"
-                   20
-                 else
-                   10
-                 end
-    else
-      priority = priority.to_i
-    end
-
-    [token, priority]
-  end
-
-  def self.match(entries, give_token)
-    priorities = {}
-    entries.each do |tokens, value|
-      best_prio = nil
-      tokens = [tokens] unless Array === tokens
-      tokens.each do |tok|
-        tok, prio = token_priority tok
-        next unless tok == give_token
-
-        best_prio = prio if best_prio.nil? or best_prio > prio
-        next if prio > best_prio
-
-        priorities[prio] ||= []
-        priorities[prio].unshift value
-      end
-    end if entries
-    priorities
-  end
-
-  # For equal priorities the matching prioritizes tokens ealier in the list
-  def self.get(key, *tokens)
-    options = tokens.pop if Hash === tokens.last
-    default = options.nil? ? nil : options[:default]
-
-    tokens = ["key:" + key] if tokens.empty?
-
-    tokens = tokens.flatten
-    file, _sep, line = caller.reject{|l| 
-      l =~ /rbbt\/(?:resource\.rb|workflow\.rb)/ or
-        l =~ /rbbt\/resource\/path\.rb/ or
-        l =~ /rbbt\/util\/misc\.rb/ or
-        l =~ /accessor\.rb/ or
-        l =~ /progress-monitor\.rb/ 
-    }.first.partition(":")
-
-    File.expand_path(file)
-
-    tokens << ("file:" << file)
-    tokens << ("line:" << file << ":" << line.sub(/:in \`.*/,''))
-
-    entries = CACHE[key.to_s]
-    priorities = {}
-    tokens.each do |token|
-      token_prio = match entries, token.to_s
-      token_prio.each do |prio, values|
-        priorities[prio] ||= []
-        priorities[prio].concat(values)
-      end
-    end
-
-    value = priorities.empty? ? default : priorities.collect{|p| p }.sort_by{|p,v| p}.first.last.first
-    value = false if value == 'false'
-
-    Log.debug "Value #{value.inspect} for config key '#{ key }': #{tokens * ", "}"
-    GOT_KEYS << [key, value, tokens]
-
-    if String === value && m = value.match(/^env:(.*)/)
-      variable = m.captures.first
-      ENV[variable]
-    elsif value == 'nil'
-      nil
-    else
-      value
-    end
-  end
-
-  def self.with_config
-      saved_config = {}
-      CACHE.each do |k,v|
-        saved_config[k] = v.dup
-      end
-      saved_got_keys = GOT_KEYS.dup
-    begin
-      yield
-    ensure
-      CACHE.replace(saved_config)
-      GOT_KEYS.replace(saved_got_keys)
-    end
-  end
-
-  def self.process_config(config)
-    if Path.is_filename?(config) && File.exist?(config)
-      Scout::Config.load_file(config)
-    elsif Scout.etc.config_profile[config].exists?
-      Scout::Config.load_file(Scout.etc.config_profile[config].find)
-    else
-      key, value, *tokens = config.split(/\s/)
-      tokens = tokens.collect do |tok|
-        tok, _sep, prio = tok.partition("::")
-        prio = "0" if prio.nil? or prio.empty?
-        [tok, prio] * "::"
-      end
-      Scout::Config.set({key => value}, *tokens)
-    end
-  end
-
-
-  self.load_config
-end

data/lib/scout/exceptions.rb

@@ -1,151 +0,0 @@
-class ScoutDeprecated < StandardError; end
-class ScoutException < StandardError; end
-
-class FieldNotFoundError < StandardError;end
-
-class TryAgain < StandardError; end
-class StopInsist < Exception
-  attr_accessor :exception
-  def initialize(exception)
-    @exception = exception
-  end
-end
-
-class Aborted < StandardError; end
-
-class ParameterException < ScoutException; end
-class MissingParameterException < ParameterException
-  def initialize(parameter)
-    super("Missing parameter '#{parameter}'")
-  end
-end
-class ProcessFailed < StandardError; 
-  attr_accessor :pid, :msg
-  def initialize(pid = Process.pid, msg = nil)
-    @pid = pid
-    @msg = msg
-    if @pid
-      if @msg
-        message = "Process #{@pid} failed - #{@msg}"
-      else
-        message = "Process #{@pid} failed"
-      end
-    else
-      message = "Failed to run #{@msg}"
-    end
-    super(message)
-  end
-end
-
-class ConcurrentStreamProcessFailed < ProcessFailed
-  attr_accessor :concurrent_stream
-  def initialize(pid = Process.pid, msg = nil, concurrent_stream = nil)
-    super(pid, msg)
-    @concurrent_stream = concurrent_stream
-  end
-end
-
-class OpenURLError < StandardError; end
-
-class DontClose < Exception
-  attr_accessor :payload
-  def initialize(payload = nil)
-    @payload = payload
-  end
-end
-
-
-class KeepLocked < Exception
-  attr_accessor :payload
-  def initialize(payload)
-    @payload = payload
-  end
-end
-
-class KeepBar < Exception
-  attr_accessor :payload
-  def initialize(payload)
-    @payload = payload
-  end
-end
-
-class LockInterrupted < TryAgain; end
-
-class ClosedStream < StandardError; end
-
-class DoneProcessing < Exception
-  attr_accessor :pid
-  def initialize(pid = Process.pid)
-    @pid = pid
-  end
-
-  def message
-    "Done processing pid #{pid}"
-  end
-end
-
-class WorkerException < ScoutException
-  attr_accessor :worker_exception, :pid
-  def initialize(worker_exception, pid)
-    @worker_exception = worker_exception
-    @pid = pid
-  end
-end
-
-class SemaphoreInterrupted < TryAgain; end
-
-#class OpenGzipError < StandardError; end
-#
-#
-#class TryThis < StandardError
-#  attr_accessor :payload
-#  def initialize(payload = nil)
-#    @payload = payload
-#  end
-#end
-#
-#class SemaphoreInterrupted < TryAgain; end
-#
-#class RemoteServerError < StandardError; end
-#
-#class DependencyError < Aborted
-#  def initialize(msg)
-#    if defined? Step and Step === msg
-#      step = msg
-#      new_msg = [step.path, step.messages.last] * ": "
-#      super(new_msg)
-#    else
-#      super(msg)
-#    end
-#  end
-#end
-#
-#class DependencyScoutException < ScoutException
-#  def initialize(msg)
-#    if defined? Step and Step === msg
-#      step = msg
-#
-#      new_msg = nil
-#      new_msg = [step.path, step.messages.last] * ": "
-#
-#      super(new_msg)
-#    else
-#      super(msg)
-#    end
-#  end
-#end
-#
-#
-#
-#
-class ResourceNotFound < ScoutException; end
-
-class SSHProcessFailed < StandardError
-  attr_accessor :host, :cmd
-  def initialize(host, cmd)
-    @host = host
-    @cmd = cmd
-    message = "SSH server #{host} failed cmd '#{cmd}'" 
-    super(message)
-  end
-end

data/lib/scout/indiferent_hash/case_insensitive.rb

@@ -1,30 +0,0 @@
-module CaseInsensitiveHash
-
-  def self.setup(hash)
-    hash.extend CaseInsensitiveHash
-  end
-
-  def downcase_keys
-    @downcase_keys ||= begin
-                         down = {} 
-                         keys.collect{|key| 
-                           down[key.to_s.downcase] = key 
-                         }
-                         down
-                       end
-  end
-
-  def [](key, *rest)
-    value = super(key, *rest)
-    return value unless value.nil?
-    key_downcase = key.to_s.downcase
-    super(downcase_keys[key_downcase])
-  end
-
-  def values_at(*keys)
-    keys.collect do |key|
-      self[key]
-    end
-  end
-  
-end

data/lib/scout/indiferent_hash/options.rb

@@ -1,115 +0,0 @@
-module IndiferentHash
-  def self.add_defaults(options, defaults = {})
-    options = string2hash options if String === options
-    IndiferentHash.setup(options)
-
-    defaults = string2hash defaults if String === defaults
-
-    defaults.each do |key, value|
-      next if options.include?(key)
-
-      options[key] = value 
-    end
-
-    options
-  end
-
-  def self.process_options(hash, *keys)
-    IndiferentHash.setup(hash)
-
-    defaults = keys.pop if Hash === keys.last
-    hash = IndiferentHash.add_defaults hash, defaults if defaults
-
-    if keys.length == 1
-      hash.include?(keys.first.to_sym) ? hash.delete(keys.first.to_sym) : hash.delete(keys.first.to_s) 
-    else
-      keys.collect do |key| hash.include?(key.to_sym) ? hash.delete(key.to_sym) : hash.delete(key.to_s) end
-    end
-  end
-
-  def self.pull_keys(hash, prefix)
-    new = {}
-    prefix = prefix.to_s
-    hash.keys.each do |key|
-      if key.to_s =~ /#{ prefix }_(.*)/
-        case
-        when String === key
-          new[$1] = hash.delete key
-        when Symbol === key
-          new[$1.to_sym] = hash.delete key
-        end
-      else
-        if key.to_s == prefix.to_s
-          new[key] = hash.delete key
-        end
-      end
-    end
-
-    IndiferentHash.setup(new)
-  end
-
-  def self.zip2hash(list1, list2)
-    hash = {}
-    list1.each_with_index do |e,i|
-      hash[e] = list2[i]
-    end
-    IndiferentHash.setup(hash)
-  end
-
-  def self.positional2hash(keys, *values)
-    if Hash === values.last
-      extra = values.pop
-      inputs = IndiferentHash.zip2hash(keys, values)
-      inputs.delete_if{|k,v| v.nil? or (String === v and v.empty?)}
-      inputs = IndiferentHash.add_defaults inputs, extra
-      inputs.delete_if{|k,v| not keys.include?(k) and not (Symbol === k ? keys.include?(k.to_s) : keys.include?(k.to_sym))}
-      inputs
-    else
-      IndiferentHash.zip2hash(keys, values)
-    end
-  end
-
-  def self.array2hash(array, default = nil)
-    hash = {}
-    array.each do |key, value|
-      value = default.dup if value.nil? and not default.nil?
-      hash[key] = value
-    end
-    IndiferentHash.setup(hash)
-  end
-
-  def self.process_to_hash(list)
-    result = yield list
-    zip2hash(list, result)
-  end
-
-  def self.hash2string(hash)
-    hash.sort_by{|k,v| k.to_s}.collect{|k,v| 
-      next unless %w(Symbol String Float Fixnum Integer Numeric TrueClass FalseClass Module Class Object).include? v.class.to_s
-      [ Symbol === k ? ":" << k.to_s : k.to_s.chomp,
-        Symbol === v ? ":" << v.to_s : v.to_s.chomp] * "="
-    }.compact * "#"
-  end
-
-  def self.string2hash(string)
-    options = {}
-
-    string.split('#').each do |str|
-      key, _, value = str.partition "="
-
-      key = key[1..-1].to_sym if key[0] == ":"
-
-      options[key] = true and next if value.empty?
-      options[key] = value[1..-1].to_sym and next if value[0] == ":"
-      options[key] = Regexp.new(/#{value[1..-2]}/) and next if value[0] == "/" and value[-1] == "/"
-      options[key] = value[1..-2] and next if value =~ /^['"].*['"]$/
-      options[key] = value.to_i and next if value =~ /^\d+$/
-      options[key] = value.to_f and next if value =~ /^\d*\.\d+$/
-      options[key] = true and next if value == "true"
-      options[key] = false and next if value == "false"
-      options[key] = value
-    end
-
-    IndiferentHash.setup(options)
-  end
-end

data/lib/scout/indiferent_hash.rb

@@ -1,96 +0,0 @@
-require_relative 'indiferent_hash/options'
-require_relative 'indiferent_hash/case_insensitive'
-
-module IndiferentHash
-
-  def self.setup(hash)
-    hash.extend IndiferentHash 
-    hash
-  end
-
-  def merge(other)
-    new = self.dup
-    IndiferentHash.setup(new)
-    other.each do |k,value|
-      new[k] = value
-    end
-    new
-  end
-
-  def []=(key,value)
-    delete(key)
-    super(key,value)
-  end
-
-  def _default?
-    @_default ||= self.default or self.default_proc
-  end
-
-  def [](key)
-    res = super(key) 
-    return res unless res.nil? or (_default? and not keys.include? key)
-
-    case key
-    when Symbol, Module
-      super(key.to_s)
-    when String
-      super(key.to_sym)
-    else
-      res
-    end
-  end
-
-  def values_at(*key_list)
-    key_list.inject([]){|acc,key| acc << self[key]}
-  end
-
-  def include?(key)
-    case key
-    when Symbol, Module
-      super(key) || super(key.to_s)
-    when String
-      super(key) || super(key.to_sym)
-    else
-      super(key)
-    end
-  end
-
-  def delete(key)
-    case key
-    when Symbol, Module
-      v = super(key) 
-      v.nil? ? super(key.to_s) : v
-    when String
-      v = super(key)
-      v.nil? ? super(key.to_sym) : v
-    else
-      super(key)
-    end
-  end
-
-  def clean_version
-    clean = {}
-    each do |k,v|
-      clean[k.to_s] = v unless clean.include? k.to_s
-    end
-    clean
-  end
-
-  def slice(*list)
-    ext_list = []
-    list.each do |e|
-      case e
-      when Symbol
-        ext_list << e
-        ext_list << e.to_s
-      when String
-        ext_list << e
-        ext_list << e.to_sym
-      else
-        ext_list << e
-      end
-    end
-    IndiferentHash.setup(super(*ext_list))
-  end
-end
-