marty 1.2.9 → 2.0.0

data/lib/marty/monkey.rb

@@ -67,7 +67,7 @@ module ActiveRecord
             super
           end
 
-          def type_cast_for_database(value)
+          def deserialize(value)
             super
           end
         end
@@ -76,34 +76,6 @@ module ActiveRecord
   end
 end
 
-
-module ActiveRecord
-  module ConnectionAdapters
-    module PostgreSQL
-      module OID # :nodoc:
-        class Array
-
-          # In the 4.2.1 version of this code, under Mutable, the code
-          # checks for raw_old_value != type_cast_for_database(new_value)
-          #
-          # Since this is comparing db (string) version, we end up
-          # comparing "{1}"!="{1.0}" for float arrays. The following
-          # is a hack to check the new_value which is the ruby array.
-          # This could be problematic in other ways.  But, works for
-          # our purposes.  FIXME: In Rails 5.0 all this code has been
-          # changed and this should no longer be an issue.
-
-
-          def changed_in_place?(raw_old_value, new_value)
-            new_value != type_cast_from_database(raw_old_value)
-          end
-
-        end
-      end
-    end
-  end
-end
-
 ######################################################################
 
 # Rails 4 doesn't handle 'infinity' datetime properly due to
@@ -249,7 +221,7 @@ module ActiveRecord
     module PostgreSQL
       module OID
         class Enum < Type::Value
-          def type_cast_from_database(value)
+          def cast(value)
             value && StringEnum.new(value)
           end
         end

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "1.2.9"
+  VERSION = "2.0.0"
 end

data/marty.gemspec

@@ -28,14 +28,13 @@ Gem::Specification.new do |s|
 
   s.add_dependency "pg", "~> 0.21"
 
-  s.add_dependency 'netzke-core', '~> 1.0.0'
-  s.add_dependency 'netzke-basepack', '~> 1.0.0'
-  s.add_development_dependency 'netzke-testing', '~> 1.0.0'
+  s.add_dependency 'netzke', '6.5.0.0'
 
   s.add_dependency 'axlsx', '3.0.0pre'
 
+
   s.add_dependency 'delorean_lang', '~> 0.3.33'
-  s.add_dependency 'mcfly', '0.0.19'
+  s.add_dependency 'mcfly', '0.0.20'
 
   s.add_dependency 'coderay'
   # FIXME: for some reason 0.16.1 doesn't work at PennyMac -- investigate

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

@@ -1,23 +1,53 @@
 class Marty::Diagnostic::Aws::Ec2Instance
-  attr_reader :id, :doc, :role, :creds, :version, :host, :tag, :nodes
-
   # aws reserved host used to get instance meta-data
   META_DATA_HOST = '169.254.169.254'
 
+  attr_reader :id,
+              :doc,
+              :role,
+              :creds,
+              :version,
+              :host,
+              :tag,
+              :nodes,
+              :instances
+
+  class InstancesSet
+    STATES = [
+      :pending, :running, :shutting_down, :terminated, :stopping, :stopped
+    ].freeze
+
+    attr_reader *STATES
+
+    def get_state instances, state
+      instances.map do
+        |i|
+        i.except('state') if i['state']['name'] == state
+      end.compact
+    end
+
+    def initialize instances
+      STATES.each do |s|
+        instance_variable_set("@#{s}", get_state(instances, s.to_s))
+      end
+    end
+  end
+
   def self.is_aws?
     response = get("http://#{META_DATA_HOST}") rescue nil
     response.present?
   end
 
   def initialize
-    @id      = get_instance_id
-    @doc     = get_document
-    @role    = get_role
-    @creds   = get_credentials
-    @host    = "ec2.#{@doc['region']}.amazonaws.com"
-    @version = '2016-11-15'
-    @tag     = get_tag
-    @nodes   = get_private_ips
+    @id            = get_instance_id
+    @doc           = get_document
+    @role          = get_role
+    @creds         = get_credentials
+    @host          = "ec2.#{@doc['region']}.amazonaws.com"
+    @version       = '2016-11-15'
+    @tag           = get_tag
+    @instances     = InstancesSet.new(get_instances)
+    @nodes         = get_private_ips
   end
 
   def self.get url
@@ -37,6 +67,7 @@ class Marty::Diagnostic::Aws::Ec2Instance
     self.class.get("http://#{META_DATA_HOST}/latest/dynamic/#{query}/")
   end
 
+  private
   def get_instance_id
     query_meta_data('instance-id').to_s
   end
@@ -85,25 +116,34 @@ class Marty::Diagnostic::Aws::Ec2Instance
   def get_instances
     params = {'Filter.1.Name'    => 'tag-value',
               'Filter.1.Value.1' => @tag}
-    ec2_request('DescribeInstances', params)
+
+    instances = ensure_resp(
+      ['reservationSet', 'item', 'instancesSet', 'item'],
+      ec2_request('DescribeInstances', params)
+    ).map do |i|
+      {
+        'id'    => i['instanceId'],
+        'ip'    => i['privateIpAddress'],
+        'state' => i['instanceState'],
+      }
+    end.flatten(1)
   end
 
   def get_private_ips
-    begin
-      reservation_set_item = get_instances['reservationSet']['item']
-      reservation_set_item = [reservation_set_item] unless
-        reservation_set_item.is_a?(Array)
+    @instances.running.map{|i| i['ip']}.compact
+  end
 
-      reservation_set_item.map{
-        |i|
-        instances_set_item = i['instancesSet']['item']
-        instances_set_item = [instances_set_item] unless
-          instances_set_item.is_a?(Array)
-
-        instances_set_item.map{|j| j['privateIpAddress']}
-      }.flatten
-    rescue => e
-      raise "Unexpected result came back from AWS. Error: (#{e.message})"
+  def ensure_resp path, obj
+    if path == []
+      obj.is_a?(Array) ? obj : [obj]
+    elsif obj.is_a?(Hash)
+      key = path.shift
+      raise "Unexpected AWS Response: #{key} missing" unless
+        (obj.is_a?(Hash) && obj[key])
+
+      ensure_resp(path, obj[key])
+    else
+      obj.map{|s| ensure_resp(path.clone, s)}.flatten(1)
     end
   end
 end

data/other/marty/diagnostic/base.rb

@@ -7,14 +7,23 @@ module Marty::Diagnostic; class Base < Request
   # should be aggregated  as these types of diagnostics are
   # aggregated differently (or not at all).
   class_attribute :aggregatable, :status_only
-  self.aggregatable = true
-  self.status_only = false
 
   @@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.generate
+  def self.diagnostic_fn opts={}
+    opts.each do |k,v|
+      send("#{k}=", v)
+    end
+    class << self
+      define_method :generate do
+        pack{yield}
+      end
+    end
+  end
+
+  diagnostic_fn aggregatable: true, status_only: false do
     raise "generate has not been defined for #{name}"
   end
 
@@ -52,7 +61,7 @@ module Marty::Diagnostic; class Base < Request
 
   def self.display data
     consistent = consistent?(data)
-    success = consistent && !fatal?
+    success    = consistent && !fatal?
     ERB.new(File.open(@@template).read).result(binding)
   end
 

data/other/marty/diagnostic/collection.rb

@@ -1,5 +1,6 @@
 module Marty::Diagnostic; class Collection < Base
   class_attribute :diagnostics
+
   self.diagnostics = []
   self.status_only = true
 

data/other/marty/diagnostic/{delayed_job.rb → delayed_job_version.rb}

@@ -5,7 +5,7 @@
 # `DELAYED_VER` environment variable should be set in the
 # delayed jobs initializer.
 #
-module Marty::Diagnostic; class DelayedJob < Base
+module Marty::Diagnostic; class DelayedJobVersion < Base
   self.aggregatable = false
 
   def self.generate
@@ -14,7 +14,7 @@ module Marty::Diagnostic; class DelayedJob < Base
     raise 'DELAYED_VER environment variable has not been initialized.' if
       ENV['DELAYED_VER'].nil?
 
-    total_workers = delayed_worker_count
+    total_workers = Node.get_target_connections('delayed').count
 
     raise 'No delayed jobs are running.' if total_workers.zero?
 
@@ -40,11 +40,5 @@ module Marty::Diagnostic; class DelayedJob < Base
       {node => {'Version' => create_info(versions.join("\n"), status)}}
     }.reduce(:deep_merge)
   end
-
-  def self.delayed_worker_count
-    db = Database.db_name
-    Node.get_postgres_connections[db].
-      count{|conn| conn['application_name'].include?('delayed_job')}
-  end
 end
 end

data/other/marty/diagnostic/delayed_job_workers.rb

@@ -0,0 +1,11 @@
+module Marty::Diagnostic; class DelayedJobWorkers < Base
+  diagnostic_fn do
+    my_ip = Node.my_ip
+    count = Node.get_target_connections('delayed').count{
+      |ip|
+      (ip == my_ip || ip == '127.0.0.1')
+    }
+    count.zero? ? error(count) : count
+  end
+end
+end

data/other/marty/diagnostic/environment_variables.rb

@@ -1,4 +1,8 @@
 module Marty::Diagnostic; class EnvironmentVariables < Base
+  diagnostic_fn do
+    env
+  end
+
   def self.env filter=''
     env = ENV.clone
 
@@ -14,12 +18,6 @@ module Marty::Diagnostic; class EnvironmentVariables < Base
       h[k] = v if to_block.all?{|b| !k.include?(b)} && k.include?(filter)}
   end
 
-  def self.generate
-    pack do
-      env
-    end
-  end
-
   # overwritten to only return inconsitent data
   def self.apply_consistency data
     diff = get_difference(data)

data/other/marty/diagnostic/fatal.rb

@@ -1,9 +1,4 @@
 module Marty::Diagnostic; class Fatal < Base
-  def self.display_alert_message
-    '<h3 class="error">Something went wrong.</br>'\
-    'Consistency is checked between remaining nodes if applicable.</h3>'
-  end
-
   def self.message msg, opts = {}
     node = opts[:node] || Node.my_ip
     type = opts[:type] || 'RuntimeError'

data/other/marty/diagnostic/node.rb

@@ -24,12 +24,13 @@ module Marty::Diagnostic::Node
     get_postgres_connections[Marty::Diagnostic::Database.db_name].select{|conn|
       conn['application_name'].include?(target)
     }.map{|conn|
-      conn['client_addr'] == '127.0.0.1' ? my_ip : conn['client_addr']
-    }.uniq.compact
+      conn['client_addr'] == '127.0.0.1' ? my_ip :
+        conn['client_addr'] || '127.0.0.1'
+    }
   end
 
   def self.get_nodes
-    nodes = get_target_connections('Passenger')
+    nodes = get_target_connections('Passenger').uniq.compact
     nodes.empty? ? [my_ip] : nodes
   end
 end

data/other/marty/diagnostic/nodes.rb

@@ -1,21 +1,54 @@
 require_relative 'aws/ec2_instance'
 
 module Marty::Diagnostic; class Nodes < Base
-  def self.generate
-    pack do
-      begin
-        a_nodes = Aws::Ec2Instance.new.nodes.sort if
-          Aws::Ec2Instance.is_aws?
-      rescue => e
-        a_nodes = [e.message]
-      end
+  diagnostic_fn aggregatable: false do
+    begin
       pg_nodes = Node.get_nodes.sort
-      a_nodes.nil? || pg_nodes == a_nodes ? pg_nodes.join("\n") :
-        error("There is a discrepancy between nodes connected to "\
-              "Postgres and those discovered through AWS EC2.\n"\
-              "Postgres: \n#{pg_nodes.join("\n")}\n"\
-              "AWS: \n#{a_nodes.join("\n")}")
+    rescue => e
+      next error(e.message)
     end
+
+    next pg_nodes.join("\n") unless
+      Marty::Diagnostic::Aws::Ec2Instance.is_aws?
+
+    begin
+      instance_data = Marty::Diagnostic::Aws::Ec2Instance.new
+    rescue => e
+      next error(pg_nodes.join("\n") +
+                 "\nAws Communication Error: #{e.message}")
+    end
+
+    begin
+      a_nodes = instance_data.nodes.sort
+      next pg_nodes.join("\n") if a_nodes == pg_nodes
+
+      # generate instance information when there is an issue
+      # between aws and postgres
+      instances = instance_data.instances
+      {'nodes' => error("There is a discrepancy between nodes connected to "\
+                        "Postgres and those discovered through AWS EC2.\n"\
+                        "Postgres: \n#{pg_nodes.join("\n")}\n"\
+                        "AWS: \n#{a_nodes.join("\n")}"),
+       'pending'       => error_if(instances.pending),
+       'running'       => valid_if(instances.running),
+       'shutting_down' => error_if(instances.shutting_down),
+       'terminated'    => error_if(instances.terminated),
+       'stopping'      => error_if(instances.stopping),
+       'stopped'       => error_if(instances.stopped),
+      }.delete_if{|k,v| v.empty?}
+    rescue => e
+      error(e.message)
+    end
+  end
+
+  def self.valid_if arr
+    return arr.join("\n") unless arr.empty?
+    error('---')
+  end
+
+  def self.error_if arr
+    return arr if arr.empty?
+    error(arr.join("\n"))
   end
 end
 end

data/other/marty/diagnostic/packer.rb

@@ -1,36 +1,33 @@
 module Marty::Diagnostic; module Packer
-  # expects a block that returns either a String or a Hash value and formats
-  # it into a diagnostic info object.
   def pack include_ip=true
-    begin
-      data = yield
-      info = case data
-             when Hash
-               is_valid_info?(data) ? {name.demodulize => data} :
-                 data.each_with_object({}) do
-                 |(key, value), hash|
-                 case value
-                 when Hash
-                   raise "Invalid Diagnostic Info #{value}" unless
-                     is_valid_info?(value)
+    info = process(yield)
+    include_ip ? {Node.my_ip => info} : info
+  end
+
+  def process obj
+    obj.is_a?(Hash) ? process_hash(obj) :
+      {name.demodulize => create_info(obj.to_s)}
+  end
+
+  def process_hash data
+    return {name.demodulize => data} if is_valid_info?(data)
 
-                   hash[key] = value
-                 else
-                   hash[key] = create_info(value.to_s)
-                 end
-               end
-             else
-               {name.demodulize => create_info(data.to_s)}
-             end
-      include_ip ? {Node.my_ip => info} : info
+    data.each_with_object({}) do
+      |(k, v), h|
+      if v.is_a?(Hash)
+        raise "Invalid Diagnostic Info #{v}" unless is_valid_info?(v)
+        h[k] = v
+      else
+        h[k] = create_info(v)
+      end
     end
   end
 
   def create_info description, status=true, consistent=nil
     {
-      'description' => description,
-      'status' => status,
-      'consistent' => consistent
+      'description' => description.to_s,
+      'status'      => status,
+      'consistent'  => consistent
     }
   end