marty 1.0.44 → 1.0.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 817a8f32d8a912597e8941cb60889a6f9e3723bc
-  data.tar.gz: cccaf421c0216156db7c106b69577f0e363c4c58
+  metadata.gz: 0437c9ffb81afc74c8bd834226b6855064e0d8bf
+  data.tar.gz: 27f841b78da83b42493bb74e5a6d3ee5944ee3b0
 SHA512:
-  metadata.gz: 030c85527c4809aeb5a18634425c5dc5924534b7f8b3f44fc83189adccfc7724b87b97e06cdeac5c5004b1301c4f9745918bcb47c8004ac0b07492d6e2fcc2b3
-  data.tar.gz: dcbabb68d76e981e927eda2e9c8e9b3a31a4896ef66561f7bcaa1d553fc31f4b8e5d056b084b7199982e242f67938964ec59366b645588c7e266a97d9ea724aa
+  metadata.gz: 1ab061544b74d83b417815f07a85e3e8ee106a9ee03da67b0e54974b749dfdcb3a57387bc1e60f55a62fefc994ec15e5c59228d4ebe58e11999da2a7d9e816fb
+  data.tar.gz: a5466cb70f5908c1c2a93cf96b938fa10815f8b2683d0502a1293a04f75b943796f9bc0518ca180d2fdfe70eb3efcfdb2fe70f9353bf2e913a1e8ac14c6cdd17

data/Gemfile

@@ -11,6 +11,9 @@ gem 'mime-types', '< 3.0', platforms: :ruby_19
 gem 'rails', '~> 4.2.1'
 gem 'pg', '~> 0.18.4'
 gem 'sqlite3'
+# for signing of aws ec2 requests
+gem 'aws-sigv4', '~> 1.0', '>= 1.0.2'
+
 
 group :development, :test do
   gem 'pry-rails'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    marty (1.0.44)
+    marty (1.0.46)
       axlsx (= 2.1.0pre)
       coderay
       delorean_lang (~> 0.1)
@@ -54,6 +54,7 @@ GEM
     addressable (2.5.2)
       public_suffix (>= 2.0.2, < 4.0)
     arel (6.0.4)
+    aws-sigv4 (1.0.2)
     axlsx (2.1.0.pre)
       htmlentities (~> 4.3.1)
       nokogiri (>= 1.4.1)
@@ -81,7 +82,7 @@ GEM
     delayed_job_active_record (4.1.2)
       activerecord (>= 3.0, < 5.2)
       delayed_job (>= 3.0, < 5)
-    delorean_lang (0.3.30)
+    delorean_lang (0.3.32)
       activerecord (>= 3.2)
       treetop (~> 1.5)
     diff-lcs (1.3)
@@ -205,6 +206,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  aws-sigv4 (~> 1.0, >= 1.0.2)
   capybara
   daemons (~> 1.1.9)
   database_cleaner

data/app/controllers/marty/diagnostic_controller.rb

@@ -1,101 +1,353 @@
+require 'erb'
 module Marty
   class DiagnosticController < ActionController::Base
-    layout 'marty/diagnostic'
-
-    def index
-      if action_methods.include?(params[:testop].to_s)
-        send(params[:testop])
-      elsif params[:testop] == 'env'
-        send('environment')
+    layout false
+    def op
+      begin
+        # inject request into Base class of all diagnostics
+        Base.request   = request
+        params[:scope] = 'nodal' unless params[:scope]
+        diag = self.class.get_sub_class(params[:op])
+        @result = params[:scope] == 'local' ? diag.generate : diag.aggregate
+      rescue NameError
+        render file: 'public/400', formats: [:html], status: 400, layout: false
       else
-        render file: 'public/404', status: 404, layout: false
+        respond_to do |format|
+          format.html {@result = diag.display(@result, params[:scope])}
+          format.json {render json: @result}
+        end
       end
     end
 
-    def version
-      diag_response git_details +
-        [Diagnostic.new('Marty Version', true, VERSION)]
+    def self.get_sub_class klass
+      const_get(klass.downcase.camelize)
     end
 
-    def environment
-      rbv = "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
-
-      details = [
-        Diagnostic.new('Environment', true, Rails.env),
-        Diagnostic.new('Rails Version', true, Rails.version),
-        Diagnostic.new('Netzke Core Version', true, Netzke::Core::VERSION),
-        Diagnostic.new('Netzke Basepack Version', true,
-                       Netzke::Basepack::VERSION),
-        Diagnostic.new('Ruby Version', true, rbv),
-        Diagnostic.new('RubyGems Version', true, Gem::VERSION),
-        Diagnostic.new('Database Adapter', true,
-                       ActiveRecord::Base.connection.adapter_name)
-      ]
-      begin
-        status = true
-        result = ActiveRecord::Base.connection.execute('SELECT VERSION();')
-        message = result[0]['version'] if result
-      rescue => e
-        status = false
-        message = e.message
+    private
+    ############################################################################
+    #
+    # Diagnostics
+    #
+    ############################################################################
+    class Base
+      @@request     = nil
+      @@read_only   = Marty::Util.db_in_recovery?
+
+      def self.request= req
+       @@request = req
       end
-      details << Diagnostic.new('Database Version', status, message)
 
-      begin
-        status, message = true, ActiveRecord::Migrator.current_version
-      rescue => e
-        status = false
-        message = e.message
+      def self.request
+        @@request
+      end
+
+      def self.aggregate op_name=name.demodulize
+        get_nodal_diags(op_name)
+      end
+
+      def self.get_nodal_diags op_name, scope='local'
+         self.get_nodes.map do |n|
+          ssl = ENV['HTTPS'] == 'on'
+          uri = Addressable::URI.new(host: n, port: ssl ? 443 : @@request.port)
+          uri.query_values = {op: op_name.underscore,
+                              scope: scope}
+          uri.scheme = ssl ? 'https' : 'http'
+          uri.path = '/marty/diag.json'
+          opts = {ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE}
+          {n => JSON.parse(open(uri, opts).readlines[0])}
+         end.sum
+      end
+
+      def self.errors data
+        data.keys.count{|n| is_failure?(data[n])}
+      end
+
+      def self.diff data
+        data.keys.map{|n| data[n]}.uniq.length != 1
+      end
+
+      def self.package message
+        {name.demodulize => message}
+      end
+
+      def self.is_failure? message
+        message.to_s.include?('Failure')
+      end
+
+      def self.error message
+        "Failure: (#{message})"
+      end
+
+      def self.display data, type='nodal'
+        data = {'local' => data} if type == 'local'
+        display = <<-ERB
+                <% inconsistent = diff(data) %>
+                <h3><%=name.demodulize%></h3>
+                <%='<h3 class="error">&#x26a0; Issues Detected</h3>' if
+                   inconsistent%>
+                <div class="wrapper">
+                <% data.each do |node, result| %>
+                    <table>
+                    <% issues = ('error' if inconsistent) %>
+                    <th class="<%=issues%>"><%=inconsistent ? node :
+                                             '<small>consistent</small>'%></th>
+                    <th class="<%=issues%>"></th>
+                    <% result.each do |name, value| %>
+                      <tr class="<%=is_failure?(value) ? 'failed' :
+                                    'passed' %>">
+                        <td><%=name%></td>
+                        <td class="overflow"><%=value%></td>
+                      </tr>
+                    <% end %>
+                    </table>
+                  <% break unless inconsistent %>
+                <% end %>
+                </div>
+                ERB
+        ERB.new(display.html_safe).result(binding)
+      end
+
+      def self.get_pg_connections
+        info = ActiveRecord::Base.connection.execute("SELECT datname,"\
+                                                     "application_name,"\
+                                                     "state,"\
+                                                     "pid,"\
+                                                     "client_addr "\
+                                                     "FROM pg_stat_activity")
+        info.each_with_object({}) do |x, h|
+          h[x["datname"]] ||= []
+          h[x["datname"]] << {"name"   => x["application_name"],
+                              "address"=> x["client_addr"],
+                              "state"  => x["state"],
+                              "pid"    => x["pid"]}
+        end
+      end
+
+      def self.resolve_target_nodes target
+        db = ActiveRecord::Base.connection_config[:database]
+        db_conns = get_pg_connections
+        target_conns = db_conns[db].select{|x|
+          x['name'].include? target}
+        target_conns.map{|x| x['address']}.uniq.compact
+      end
+
+      def self.get_nodes
+        nodes = resolve_target_nodes("Passenger")
+        nodes.empty? ? ['127.0.0.1'] : nodes
+      end
+    end
+    ############################################################################
+    #
+    # Diagnostic Definitions
+    # Default: pulls from all nodes; force local with '&scope=local'
+    #
+    ############################################################################
+    class Version < Base
+      def self.generate
+        begin
+          message = `cd #{Rails.root.to_s}; git describe;`.strip
+        rescue
+          message = error("Failed accessing git")
+        end
+        {
+          'Git'      => message,
+          'Marty'    => Marty::VERSION,
+          'Delorean' => Delorean::VERSION,
+          'Mcfly'    => Mcfly::VERSION
+        }
       end
-      details << Diagnostic.new('Database Schema Version', status, message)
-      diag_response details
     end
 
-  private
-    def diag_response details
-      if @aggregate_diags
-        @aggregated_details += details
-      else
-        @details = details
-        respond_to do |format|
-          format.html { render 'diagnostic' }
-          format.json { render json: [{ error_count: error_count(details),
-                                       diag_count: details.count }] + details }
+    class Database < Base
+      def self.db_server_name
+        ActiveRecord::Base.connection_config[:host] || 'undefined'
+      end
+
+      def self.db_adapter_name
+        ActiveRecord::Base.connection.adapter_name
+      end
+
+      def self.db_time
+        ActiveRecord::Base.connection.execute('SELECT NOW();')
+      end
+
+      def self.db_version
+        begin
+        message = ActiveRecord::Base.connection.
+                    execute('SELECT VERSION();')[0]['version']
+        rescue => e
+          return error(message)
+        end
+        message
+      end
+
+      def self.db_schema
+        begin
+          message = ActiveRecord::Migrator.current_version
+        rescue => e
+          return error(e.message)
         end
+        message
       end
     end
 
-    def aggregate_diags
-      begin
-        @aggregate_diags = true
-        @aggregated_details = []
-        yield
-      ensure
-        @aggregate_diags = false
-        diag_response @aggregated_details
+    class Environment < Database
+      def self.generate
+        rbv = "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
+        infos = {'Environment'             => Rails.env,
+                 'Rails'                   => Rails.version,
+                 'Netzke Core'             => Netzke::Core::VERSION,
+                 'Netzke Basepack'         => Netzke::Basepack::VERSION,
+                 'Ruby'                    => rbv,
+                 'RubyGems'                => Gem::VERSION,
+                 'Database Adapter'        => db_adapter_name,
+                 'Database Server'         => db_server_name,
+                 'Database Version'        => db_version,
+                 'Database Schema Version' => db_schema}
       end
     end
 
-    def error_count details
-      details.count { |detail| !detail.status }
+    class Nodes < Base
+      def self.generate
+        a_nodes  = AwsInstanceInfo.is_aws? ? AwsInstanceInfo.new.nodes.sort : []
+        pg_nodes = get_nodes.sort
+        message  = pg_nodes == a_nodes ? pg_nodes.join(', ') :
+                     error("Postgres: [#{pg_nodes.join(', ')}]"\
+                           " - AWS: [#{a_nodes.join(', ')}]")
+        {"PG/AWS" => message}
+      end
+
+      def self.aggregate
+        {'local' => generate}
+      end
     end
 
-    def git_details app_name = Rails.application.class.parent.to_s
-      [
-        Diagnostic.new("#{app_name} Git Version", true,
-               `git describe 2>&1`.strip),
-        Diagnostic.new("#{app_name} Git Details", true,
-               `git show --pretty=format:"sha: %h, %D" --no-patch 2>&1`.strip)
-      ]
+    ############################################################################
+    #
+    # Reports
+    #
+    ############################################################################
+    class Report < Base
+      class << self
+        attr_accessor :diags
+      end
+
+      def diags
+        self.class.diags
+      end
+
+      self.diags = ['nodes', 'version', 'environment']
+
+      def self.get_diag_klass diag
+        controller = name.split(name.demodulize)[0].constantize
+        controller.const_get(diag.capitalize)
+      end
+
+      def self.generate
+        diags.each_with_object({}){|d, h| h[d] = get_diag_klass(d).generate}
+      end
+
+      def self.aggregate
+        diags.each_with_object({}){|d, h| h[d] = get_diag_klass(d).aggregate}
+      end
+
+      def self.display data, type
+        report = '<h3>' +
+                 name.demodulize +
+                 " #{'(' + type + ')' if type == 'local'}" +
+                 '</h3>'
+        displays = diags.map{|d| get_diag_klass(d).display(data[d], type)}
+        ([report] + displays).sum
+      end
     end
 
-    class Diagnostic < Struct.new(:name, :status, :description)
-      def status_css
-        status ? 'passed' : 'failed'
+    ############################################################################
+    #
+    # AWS Helper Class
+    #
+    ############################################################################
+    class AwsInstanceInfo
+      attr_accessor :id, :doc, :role, :creds, :version, :host, :tag, :nodes
+
+      # aws reserved host used to get instance meta-data
+      META_DATA_HOST = '169.254.169.254'
+
+      def self.is_aws?
+        uri = URI.parse("http://#{META_DATA_HOST}")
+        !(Net::HTTP.get(uri) rescue nil).nil?
+      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
+      end
+
+      private
+      def query_meta_data query
+        uri = URI.parse("http://#{META_DATA_HOST}/latest/meta-data/#{query}/")
+        Net::HTTP.get(uri)
+      end
+
+      def query_dynamic query
+        uri = URI.parse("http://#{META_DATA_HOST}/latest/dynamic/#{query}/")
+        Net::HTTP.get(uri)
+      end
+
+      def get_instance_id
+        query_meta_data('instance-id').to_s
+      end
+
+      def get_role
+        query_meta_data('iam/security-credentials').to_s
+      end
+
+      def get_credentials
+        JSON.parse(query_meta_data("iam/security-credentials/#{@role}"))
+      end
+
+      def get_document
+        JSON.parse(query_dynamic('instance-identity/document'))
+      end
+
+      def ec2_req action, params = {}
+        url = "https://#{@host}/?Action=#{action}&Version=#{@version}"
+        params.each{|a, v| url += "&#{a}=#{v}"}
+
+        sig = Aws::Sigv4::Signer.new(service:           'ec2',
+                                     region:            @doc['region'],
+                                     access_key_id:     @creds['AccessKeyId'],
+                                     secret_access_key: @creds['SecretAccessKey'],
+                                     session_token:     @creds['Token'])
+        signed_url = sig.presign_url(http_method:'GET', url: url)
+
+        http = Net::HTTP.new(@host, 443)
+        http.use_ssl = true
+        Hash.from_xml(Net::HTTP.get(signed_url))["#{action}Response"]
+      end
+
+      def get_tag
+        params = {'Filter.1.Name'    => 'resource-id',
+                  'Filter.1.Value.1' => get_instance_id,
+                  'Filter.2.Name'    => 'key',
+                  'Filter.2.Value.1' => 'Name'}
+        ec2_req('DescribeTags', params)['tagSet']['item']['value']
+      end
+
+      def get_instances
+        params = {'Filter.1.Name'    => 'tag-value',
+                  'Filter.1.Value.1' => @tag}
+        ec2_req('DescribeInstances', params)
       end
 
-      def status_text
-        status ? 'Passed' : 'Failed'
+      def get_private_ips
+        get_instances['reservationSet']['item'].
+          map{|i| i['instancesSet']['item']['privateIpAddress']}
       end
     end
   end