marty 2.5.2 → 2.5.4

data/make-dummy.mk

@@ -20,10 +20,13 @@ dummy-app-console:
 	docker-compose --file=docker-compose.dummy.yml run --rm app bin/rails c
 
 dummy-app-initialise-docker:
+	touch .bash_history.docker
+	touch .pry_history.docker
 	make dummy-app-install
 	make dummy-app-db-prepare
 
 dummy-app-install:
+	docker-compose --file=docker-compose.dummy.yml run --rm app gem install bundler
 	make dummy-app-install-bundle
 
 dummy-app-install-bundle:

data/marty.gemspec

@@ -1,32 +1,32 @@
-$:.push File.expand_path("../lib", __FILE__)
+$:.push File.expand_path('../lib', __FILE__)
 
-require "marty/version"
-require "digest/md5"
-require "base64"
-require "zlib"
-require "csv"
+require 'marty/version'
+require 'digest/md5'
+require 'base64'
+require 'zlib'
+require 'csv'
 
 Gem::Specification.new do |s|
-  s.name        = "marty"
+  s.name        = 'marty'
   s.version     = Marty::VERSION
   s.authors     = [
-    "Arman Bostani",
-    "Brian VanLoo",
-    "Chad Edie",
-    "Eric Litwin",
-    "Iliana Toneva",
-    "Jock Cooper",
-    "Masaki Matsuo",
+    'Arman Bostani',
+    'Brian VanLoo',
+    'Chad Edie',
+    'Eric Litwin',
+    'Iliana Toneva',
+    'Jock Cooper',
+    'Masaki Matsuo',
   ]
-  s.email       = ["arman.bostani@pnmac.com"]
-  s.homepage    = "https://github.com/arman000/marty"
-  s.summary     = "A framework for working with versioned data"
+  s.email       = ['arman.bostani@pnmac.com']
+  s.homepage    = 'https://github.com/arman000/marty'
+  s.summary     = 'A framework for working with versioned data'
   s.description =
-    "Marty is a framework for viewing and reporting on versioned data."
+    'Marty is a framework for viewing and reporting on versioned data.'
   s.files       = `git ls-files`.split($\)
   s.licenses    = ['MIT']
 
-  s.add_dependency "pg", "~> 0.21"
+  s.add_dependency 'pg', '~> 0.21'
 
   s.add_dependency 'netzke', '6.5.0.0'
 
@@ -36,14 +36,14 @@ Gem::Specification.new do |s|
   s.add_dependency 'mcfly', '0.0.20'
 
   s.add_dependency 'coderay'
+  s.add_dependency 'json-schema'
   s.add_dependency 'net-ldap', '~> 0.16.1'
   s.add_dependency 'rubyzip'
   s.add_dependency 'sqlite3'
-  s.add_dependency 'json-schema'
 
   # used for signing aws ec2 requests
   s.add_dependency 'aws-sigv4', '~> 1.0', '>= 1.0.2'
 
-  s.add_dependency 'delayed_job_active_record'
   s.add_dependency 'daemons', '~> 1.3.1'
+  s.add_dependency 'delayed_job_active_record'
 end

data/other/marty/api/base.rb

@@ -11,11 +11,11 @@ class Marty::Api::Base
     result = yield
     controller.respond_to do |format|
       format.json { controller.send_data result.to_json }
-      format.csv  {
+      format.csv  do
         # SEMI-HACKY: strip outer list if there's only one element.
-        result = result[0] if result.is_a?(Array) && result.length==1
+        result = result[0] if result.is_a?(Array) && result.length == 1
         controller.send_data Marty::DataExporter.to_csv(result)
-      }
+      end
     end
   end
 
@@ -60,27 +60,27 @@ class Marty::Api::Base
       # get_schema will either return a hash with the schema,
       # or a string with the error
       input_schema = @@schemas[schema_key] ||=
-                     Marty::JsonSchema.get_schema(*schema_key)
-    rescue => e
-      return {error: e.message}
+                       Marty::JsonSchema.get_schema(*schema_key)
+    rescue StandardError => e
+      return { error: e.message }
     end
 
     # validate input schema
     if config[:input_validated]
 
       # must fail if schema not found or some other error
-      return {"error": input_schema} if input_schema.is_a?(String)
+      return { "error": input_schema } if input_schema.is_a?(String)
 
       begin
         res = SchemaValidator::validate_schema(input_schema, params[:params])
       rescue NameError
-        return {error: "Unrecognized PgEnum for attribute #{params[:attr]}"}
-      rescue => e
-        return {error: "#{params[:attr]}: #{e.message}"}
+        return { error: "Unrecognized PgEnum for attribute #{params[:attr]}" }
+      rescue StandardError => e
+        return { error: "#{params[:attr]}: #{e.message}" }
       end
 
       schema_errors = SchemaValidator::get_errors(res) unless res.empty?
-      return {error: "Error(s) validating: #{schema_errors}"} if
+      return { error: "Error(s) validating: #{schema_errors}" } if
         schema_errors
     end
 
@@ -88,23 +88,23 @@ class Marty::Api::Base
     if input_schema.is_a?(Hash)
       # fix numbers types
       numbers = @@numbers[schema_key] ||=
-                Marty::JsonSchema.get_numbers(input_schema)
+                  Marty::JsonSchema.get_numbers(input_schema)
 
       # modify params in place
       Marty::JsonSchema.fix_numbers(params[:params], numbers)
-    elsif !input_schema.include?("Schema not defined")
+    elsif !input_schema.include?('Schema not defined')
       # else if some error besides schema not defined, fail
-      return {error: input_schema}
+      return { error: input_schema }
     end
 
     # get script engine
     begin
       engine = Marty::ScriptSet.new(params[:tag]).get_engine(params[:script])
-    rescue => e
+    rescue StandardError => e
       error = "Can't get engine: #{params[:script] || 'nil'} with tag: " +
                 "#{params[:tag] || 'nil'}; message: #{e.message}"
       Marty::Logger.info error
-      return {error: error}
+      return { error: error }
     end
 
     retval = nil
@@ -116,7 +116,7 @@ class Marty::Api::Base
                                      params[:params],
                                      params[:attr])
 
-        return retval = {"job_id" => res.__promise__.id}
+        return retval = { 'job_id' => res.__promise__.id }
       end
 
       res = engine.evaluate(params[:node],
@@ -126,37 +126,36 @@ class Marty::Api::Base
       # validate output schema
       if config[:output_validated] && !(res.is_a?(Hash) && res['error'])
         begin
-          output_schema_params = params + {attr: params[:attr] + '_'}
+          output_schema_params = params + { attr: params[:attr] + '_' }
           schema = SchemaValidator::get_schema(output_schema_params)
-        rescue => e
-          return {error: e.message}
+        rescue StandardError => e
+          return { error: e.message }
         end
 
         begin
           schema_errors = SchemaValidator::validate_schema(schema, res)
         rescue NameError
-          return {error: "Unrecognized PgEnum for attribute #{attr}"}
-        rescue => e
-          return {error: "#{attr}: #{e.message}"}
+          return { error: "Unrecognized PgEnum for attribute #{attr}" }
+        rescue StandardError => e
+          return { error: "#{attr}: #{e.message}" }
         end
 
         if schema_errors.present?
-          errors = schema_errors.map{|e| e[:message]}
+          errors = schema_errors.map { |e| e[:message] }
 
           Marty::Logger.error(
             "API #{params[:script]}:#{params[:node]}.#{params[:attr]}",
-            {error: errors, data: res}
+            error: errors, data: res
           )
 
           msg = "Error(s) validating: #{errors}"
-          res = config[:strict_validate] ? {error: msg ,data: res} : res
+          res = config[:strict_validate] ? { error: msg, data: res } : res
         end
       end
 
       # if attr is an array, return result as an array
       return retval = params[:return_array] ? [res] : res
-
-    rescue => e
+    rescue StandardError => e
       msg = Delorean::Engine.grok_runtime_exception(e).symbolize_keys
       Marty::Logger.info "Evaluation error: #{msg}"
       return retval = msg
@@ -167,6 +166,7 @@ class Marty::Api::Base
 
   def self.filter_hash hash, filter_params
     return unless hash
+
     pf = ActionDispatch::Http::ParameterFilter.new(filter_params)
     pf.filter(hash)
   end
@@ -175,7 +175,7 @@ class Marty::Api::Base
     res     = result.is_a?(Hash) ? result.stringify_keys : result
     ret_arr = params[:return_array]
     input   = filter_hash(params[:params], engine_params_filter)
-    {script:     params[:script],
+    { script:     params[:script],
      node:       params[:node],
      attrs:      ret_arr ? [params[:attr]] : params[:attr],
      input:      input,
@@ -197,21 +197,19 @@ class Marty::Api::Base
 
   class SchemaValidator
     def self.get_schema params
-      begin
-        Marty::ScriptSet.new(params[:tag]).get_engine(params[:script]+'Schemas').
+        Marty::ScriptSet.new(params[:tag]).get_engine(params[:script] + 'Schemas').
           evaluate(params[:node], params[:attr], {})
-      rescue => e
+    rescue StandardError => e
         msg = e.message == 'No such script' ? 'Schema not defined' :
                 'Problem with schema: ' + e.message
 
         raise "Schema error for #{params[:script]}/#{params[:node]} "\
               "attrs=#{params[:attr]}: #{msg}"
-      end
     end
 
     def self.validate_schema schema, hash
       JSON::Validator.fully_validate(
-        schema.merge({"\$schema" => Marty::JsonSchema::RAW_URI}),
+        schema.merge("\$schema" => Marty::JsonSchema::RAW_URI),
         hash,
         validate_schema:   true,
         errors_as_objects: true,
@@ -224,6 +222,7 @@ class Marty::Api::Base
             match(msg)
 
       return msg unless m
+
       "disallowed parameter '#{m[1]}' of type #{m[2]} was received"
     end
 
@@ -237,7 +236,7 @@ class Marty::Api::Base
           fa, fragment, message, errors = errs.values_at(:failed_attribute,
                                                          :fragment,
                                                          :message, :errors)
-          ((['AllOf','AnyOf','Not'].include?(fa) && fragment =='#/') ?
+          ((['AllOf', 'AnyOf', 'Not'].include?(fa) && fragment == '#/') ?
              [] : [massage_message(message)]) + _get_errors(errors || {})
         end
       end

data/other/marty/diagnostic/aws/ec2_instance.rb

@@ -11,8 +11,7 @@ class Marty::Diagnostic::Aws::Ec2Instance < Marty::Aws::Request
     attr_reader *STATES
 
     def get_state instances, state
-      instances.map do
-        |i|
+      instances.map do |i|
         i.except('state') if i['state']['name'] == state
       end.compact
     end
@@ -33,22 +32,23 @@ class Marty::Diagnostic::Aws::Ec2Instance < Marty::Aws::Request
   end
 
   private
+
   def ec2_request action, params = {}
-    resp = request({action: action}, params)
+    resp = request({ action: action }, params)
     Hash.from_xml(resp)["#{action}Response"]
   end
 
   def get_tag
-    params = {'Filter.1.Name'    => 'resource-id',
+    params = { 'Filter.1.Name' => 'resource-id',
               'Filter.1.Value.1' => get_instance_id,
               'Filter.2.Name'    => 'key',
-              'Filter.2.Value.1' => 'Name'}
+              'Filter.2.Value.1' => 'Name' }
     ec2_request('DescribeTags', params)['tagSet']['item']['value']
   end
 
   def get_instances
-    params = {'Filter.1.Name'    => 'tag-value',
-              'Filter.1.Value.1' => @tag}
+    params = { 'Filter.1.Name' => 'tag-value',
+              'Filter.1.Value.1' => @tag }
 
     resp = ec2_request('DescribeInstances', params)
 
@@ -65,6 +65,6 @@ class Marty::Diagnostic::Aws::Ec2Instance < Marty::Aws::Request
   end
 
   def get_private_ips
-    @instances.running.map{|i| i['ip']}.compact
+    @instances.running.map { |i| i['ip'] }.compact
   end
 end

data/other/marty/diagnostic/base.rb

@@ -10,10 +10,10 @@ module Marty::Diagnostic; class Base < Request
 
   @@read_only = Marty::Util.db_in_recovery?
   @@template  = ActionController::Base.new.lookup_context.
-                  find_template("marty/diagnostic/diag").identifier
+                  find_template('marty/diagnostic/diag').identifier
 
-  def self.diagnostic_fn opts={}
-    opts.each do |k,v|
+  def self.diagnostic_fn opts = {}
+    opts.each do |k, v|
       send("#{k}=", v)
     end
     class << self
@@ -35,26 +35,24 @@ module Marty::Diagnostic; class Base < Request
 
   def self.process_status_only infos
     return infos unless status_only
-    infos.map{|info| info.map{|test, result| [test, result['status']]}.to_h}
+
+    infos.map { |info| info.map { |test, result| [test, result['status']] }.to_h }
   end
 
   def self.get_difference data
     values = process_status_only(data.values)
-    Marty::DataExporter.hash_array_merge(values, true).map{
-      |test, values|
+    Marty::DataExporter.hash_array_merge(values, true).map do |test, values|
       test if values.uniq.count > 1
-    }.compact
+    end.compact
   end
 
   def self.apply_consistency data
     diff = get_difference(data)
-    data.each_with_object({}){
-      |(node, diagnostic), new_data|
-      new_data[node] = diagnostic.each_with_object({}){
-        |(test, info), new_diagnostic|
-        new_diagnostic[test] = info + {'consistent' => !diff.include?(test)}
-      }
-    }
+    data.each_with_object({}) do |(node, diagnostic), new_data|
+      new_data[node] = diagnostic.each_with_object({}) do |(test, info), new_diagnostic|
+        new_diagnostic[test] = info + { 'consistent' => !diff.include?(test) }
+      end
+    end
   end
 
   def self.consistent? data
@@ -71,6 +69,7 @@ module Marty::Diagnostic; class Base < Request
     return 'inconsistent' if info.nil? || (info['status'] &&
                                            info['consistent'] == false)
     return 'error' unless info['status']
+
     'passed'
   end
 

data/other/marty/diagnostic/collection.rb

@@ -6,7 +6,8 @@ module Marty::Diagnostic; class Collection < Base
 
   def self.generate
     raise 'No diagnostics assigned to collection.' if diagnostics.empty?
-    diagnostics.map{|d| d.generate}.reduce(:deep_merge)
+
+    diagnostics.map(&:generate).reduce(:deep_merge)
   end
 end
 end

data/other/marty/diagnostic/connections.rb

@@ -2,18 +2,20 @@ module Marty::Diagnostic; class Connections < Base
   self.aggregatable = false
   diagnostic_fn do
     conns = Node.get_postgres_connections[Database.db_name].
-              sort_by{|h| [h['application_name'],
-                           h['pid'],
-                           h['client_addr'],
-                           h['state']]}
+              sort_by do |h|
+              [h['application_name'],
+               h['pid'],
+               h['client_addr'],
+               h['state']]
+    end
 
     counts = Hash.new(0)
     conns.each_with_object({}) do |c, h|
       c['client_addr'] = 'localhost' unless c['client_addr']
       name = c['application_name']
       counts[name] += 1
-      key = "#{name} #{'*' * (counts[name]-1)}"
-      h[key] = c.except('application_name').map{|k,v| "<li>#{k}: #{v}</li>"}.join
+      key = "#{name} #{'*' * (counts[name] - 1)}"
+      h[key] = c.except('application_name').map { |k, v| "<li>#{k}: #{v}</li>" }.join
     end
   end
 end

data/other/marty/diagnostic/database.rb

@@ -23,6 +23,7 @@ module Marty::Diagnostic::Database
     current = ActiveRecord::Migrator.current_version
     raise "Migration is needed.\nCurrent Version: #{current}" if
       ActiveRecord::Migrator.needs_migration?
+
     current.to_s
   end
 

data/other/marty/diagnostic/delayed_job_version.rb

@@ -20,25 +20,23 @@ module Marty::Diagnostic; class DelayedJobVersion < Base
 
     # we will only iterate by half of the total delayed workers to avoid
     # excess use of delayed job time
-    total_workers = (total_workers/2).zero? ? 1 : total_workers/2
+    total_workers = (total_workers / 2).zero? ? 1 : total_workers / 2
 
-    d_engine = Marty::ScriptSet.new.get_engine("Diagnostics")
+    d_engine = Marty::ScriptSet.new.get_engine('Diagnostics')
     res = d_engine.
-            evaluate('VersionDelay', 'result', {'count' => total_workers-1})
+            evaluate('VersionDelay', 'result', 'count' => total_workers - 1)
 
     # merge results, remove duplicates, and construct "aggregate" object
-    res.each_with_object({}){
-      |r, hash|
+    res.each_with_object({}) do |r, hash|
       hash[r[0]] ||= []
       hash[r[0]] << r[1]
-    }.map {
-      |node, result|
+    end.map do |node, result|
 
       versions = result.uniq
       status = versions.count == 1 && versions[0] == ENV['DELAYED_VER']
 
-      {node => {'Version' => create_info(versions.join("\n"), status)}}
-    }.reduce(:deep_merge)
+      { node => { 'Version' => create_info(versions.join("\n"), status) } }
+    end.reduce(:deep_merge)
   end
 end
 end