marty 1.1.5 → 1.1.6

data/app/models/diagnostic/request.rb

@@ -0,0 +1,28 @@
+class Diagnostic::Request
+  def self.request
+    raise 'Request object has not been been injected into #{name}' unless
+      @@request
+
+    @@request
+  end
+
+  def self.request= req
+    @@request = req
+  end
+
+  def self.params
+    request.params
+  end
+
+  def self.scope
+    params[:scope]
+  end
+
+  def self.op
+    params[:op]
+  end
+
+  def self.ssl?
+    request.port == 443
+  end
+end

data/app/models/diagnostic/version.rb

@@ -0,0 +1,17 @@
+class Diagnostic::Version < Diagnostic::Base
+  def self.generate
+    pack do
+      begin
+        message = `cd #{Rails.root.to_s}; git describe --tags --always;`.strip
+      rescue
+        message = error("Failed accessing git")
+      end
+      {
+        'Marty'    => Marty::VERSION,
+        'Delorean' => Delorean::VERSION,
+        'Mcfly'    => Mcfly::VERSION,
+        'Git'      => message,
+      }
+    end
+  end
+end

data/app/models/marty/helper.rb

@@ -6,14 +6,6 @@ class Marty::Helper
     Kernel.sleep seconds
   end
 
-  delorean_fn :my_ip, sig:0 do
-    Socket.ip_address_list.detect{|intf| intf.ipv4_private?}.ip_address
-  end
-
-  delorean_fn :git, sig:0 do
-    [my_ip, ENV['DELAYED_VER']]
-  end
-
   delorean_fn :range_step, sig: 3 do
     |rstart, rend, step|
     (rstart..rend).step(step).to_a

data/app/views/marty/diagnostic/diag.html.erb

@@ -1,34 +1,30 @@
-<% inconsistent = diff(data) %>
 <h3><%=name.demodulize%></h3>
-<%='<h3 class="error">Issues Detected</h3>' if
-                     inconsistent%>
+<%='<h3 class="error">Inconsistency Detected</h3>' unless consistent %>
 <div class="wrapper">
   <table>
-    <%# Create node table headers if applicable %>
+    <%# create node table headers if applicable %>
     <tr>
-      <%='<th></th>' if inconsistent %>
+      <%='<th></th>' unless success %>
       <% data.keys.each do |node| %>
-        <th <%='colspan="2"' unless inconsistent %> scope="col">
-          <%= inconsistent ? node :
-                          (type == 'local' ? 'local' : 'consistent') %>
+        <th <%='colspan="2"' if success %> scope="col">
+          <%= success ? 'consistent' : node %>
         </th>
-        <% break unless inconsistent %>
+        <% break if success %>
       <% end %>
     </tr>
-    <%# Create row headers and display node results %>
-    <% data[data.keys.first].each do |key, value| %>
+    <%# create row headers and display node results %>
+    <% data.values.map{|v| v.keys}.flatten.compact.uniq.each do |test| %>
       <tr>
-        <th scope="row"><%= key %></th>
-        <% targets = get_targets(data) %>
-        <% data.each do |_node, result| %>
-          <td class="overflow <%= (is_failure?(value) ||
-                          (result[key].to_s != targets[key].to_s)) ? 'error' :
-                          'passed' %>">
-            <%= simple_format(result[key].to_s) %>
+        <th class="data" scope="row"><%= test %></th>
+        <% data.values.each do |diagnostic| %>
+          <td class="overflow <%= display_info_css(diagnostic[test]) %>">
+            <%= display_info_description(diagnostic[test]) %>
           </td>
-          <% break unless inconsistent %>
+          <% break if success %>
         <% end %>
       </tr>
     <% end %>
   </table>
 </div>
+
+<%= display_alert_message if fatal? %>

data/app/views/marty/diagnostic/op.html.erb

@@ -10,13 +10,12 @@
        color: #333333;
        font-family: Arial, Helvetica, Verdana, sans-serif;
        font-weight: normal;
-       font-size: 9pt; }
+       font-size: 9pt;}
       table { border: none;
         border-collapse: collapse;
         display: inline-block;
         margin: 0px 5px 0px 5px;
-        text-align: left;
-      }
+        text-align: left;}
       th { padding: 9px;
            border: none;
            background-color: #d6d6d6 }
@@ -24,26 +23,26 @@
            padding: 9px;
          }
       tr { text-align: center;}
-      tr.passed { background-color: #d0e9c6 }
+      td.desc { font-size: 10pt;}
       td.passed { background-color: #d0e9c6 }
+      td.inconsistent { background-color: #ffa500 }
       td.error  { background-color: #ff5555;
-            color: #ffffff;}
-      th.error  { background-color: #ff5555;}
-      td.desc { font-size: 10pt; }
+                  color: #ffffff;}
+      td.overflow { max-width: 350px;
+                    overflow: auto;}
+      th.data { text-align: left;}
       p  { white-space: pre-line;}
-      h1 { display: block;
-           margin: 0px auto 40px auto;
-           padding: 8px;
-           background-color: #1aaa55;
-           font-size: 18pt;
-           color: #ffffff;
-           line-height: 1.5em; }
+      h1.application { display: block;
+                       margin: 0px auto 40px auto;
+                       padding: 8px;
+                       background-color: #1aaa55;
+                       font-size: 18pt;
+                       color: #ffffff;
+                       line-height: 1.5em;}
       h1.error {background-color: #ff5555;}
       h2 {text-align: center;}
       h3.error {color: red;}
       h3 {text-align: center;}
-      td.overflow { max-width: 350px;
-              overflow: auto; }
       .wrapper {
           overflow-x: auto;
           white-space: nowrap;
@@ -52,11 +51,11 @@
   </head>
   <body>
     <div style="text-align:center">
-      <h1 class="<%= 'error' if @result.to_s.include?('error') %>">
-        <%=Rails.application.class.parent_name%> Diagnostic
+      <h1 class="application <%= 'error' unless @result['errors'].empty? %>">
+        <%=ENV['DIAG_TITLE'] || Rails.application.class.parent_name%> Diagnostic
       </h1>
       <h3><i><%= DateTime.now %></i></h3>
-      <%== @result %>
+      <%== @result['display'] %>
     </div>
   </body>
 </html>

data/delorean/diagnostics.dl

@@ -3,7 +3,7 @@ Delay:
     # the delay parameter delays the next created job so that a different
     # worker is more likely to claim it
     delay  =? 2.6
-    ver    = Marty::Helper.sleep(delay) && Marty::Helper.git
+    ver    = Marty::Helper.sleep(delay) && Diagnostic::Helper.git
     res    = [(Delay() | "ver") for i in Marty::Helper.range_step(0, count, 1)]
     result = [r.to_a for r in res]
 

data/lib/diagnostic/database.rb

@@ -0,0 +1,28 @@
+module Diagnostic::Database
+  def self.db_name
+    ActiveRecord::Base.connection_config[:database]
+  end
+
+  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();')[0]['now']
+  end
+
+  def self.db_version
+    ActiveRecord::Base.connection.execute('SELECT VERSION();')[0]['version']
+  end
+
+  def self.db_schema
+    current = ActiveRecord::Migrator.current_version
+    raise "Migration is needed.\nCurrent Version: #{current}" if
+      ActiveRecord::Migrator.needs_migration?
+    current
+  end
+end

data/lib/diagnostic/node.rb

@@ -0,0 +1,35 @@
+module Diagnostic::Node
+  def self.my_ip
+    begin
+      Socket.ip_address_list.detect{|intf| intf.ipv4_private?}.ip_address
+    rescue => e
+      e.message
+    end
+  end
+
+  def self.get_postgres_connections
+    conn = ActiveRecord::Base.connection.execute('SELECT datname,'\
+                                                 'application_name,'\
+                                                 'state,'\
+                                                 'pid,'\
+                                                 'client_addr '\
+                                                 'FROM pg_stat_activity')
+    conn.each_with_object({}) do |conn, h|
+      h[conn['datname']] ||= []
+      h[conn['datname']] << conn.except('datname')
+    end
+  end
+
+  def self.get_target_connections target
+    get_postgres_connections[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
+  end
+
+  def self.get_nodes
+    nodes = get_target_connections('Passenger')
+    nodes.empty? ? [my_ip] : nodes
+  end
+end

data/lib/diagnostic/packer.rb

@@ -0,0 +1,47 @@
+module Diagnostic::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 String
+                   hash[key] = create_info(value)
+                 when Hash
+                   raise "Invalid Diagnostic Info #{value}" unless
+                     is_valid_info?(value)
+
+                   hash[key] = value
+                 end
+               end
+             when String
+               {name.demodulize => create_info(data)}
+             else
+               raise "Invalid Data Type: (#{data}, #{data.class}) "\
+                     "`package` expects a String or Hash value."
+             end
+      include_ip ? {Diagnostic::Node.my_ip => info} : info
+    end
+  end
+
+  def create_info description, status=true, consistent=nil
+    {
+      'description' => description,
+      'status' => status,
+      'consistent' => consistent
+    }
+  end
+
+  def is_valid_info? info
+    info.keys.to_set == Set['description', 'status', 'consistent']
+  end
+
+  def error description
+    create_info(description, false)
+  end
+end

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "1.1.5"
+  VERSION = "1.1.6"
 end

data/spec/controllers/diagnostic_controller_spec.rb

@@ -4,190 +4,33 @@ module Marty
     before(:each) { @routes = Marty::Engine.routes }
     let(:json_response) { JSON.parse(response.body) }
 
-    def git
-      begin
-        message = `cd #{Rails.root.to_s}; git describe --tags --always;`.strip
-      rescue
-        message = error("Failed accessing git")
-      end
-    end
-
-    def version
-      {
-        "Marty"    => Marty::VERSION,
-        "Delorean" => Delorean::VERSION,
-        "Mcfly"    => Mcfly::VERSION,
-        "Git"      => git,
-      }
-    end
-
-    def environment
-      rbv = "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
-      {'Environment'             => Rails.env,
-       'Rails'                   => Rails.version,
-       'Netzke Core'             => Netzke::Core::VERSION,
-       'Netzke Basepack'         => Netzke::Basepack::VERSION,
-       'Ruby'                    => rbv,
-       'RubyGems'                => Gem::VERSION,
-       'Database Adapter'        => described_class::Database.db_adapter_name,
-       'Database Server'         => described_class::Database.db_server_name,
-       'Database Version'        => described_class::Database.db_version,
-       'Database Schema Version' => described_class::Database.db_schema}
-    end
-
-    def version_display
-      <<-ERB
-      <h3>Version</h3>
-      <div class="wrapper">
-        <table>
-          <tr>
-            <th colspan="2" scope="col">consistent</th>
-          </tr>
-          <tr>
-            <th scope="row">Marty</th>
-            <td class="overflow passed"><p>#{Marty::VERSION}</p>
-            </td>
-          </tr>
-          <tr>
-            <th scope="row">Delorean</th>
-            <td class="overflow passed"><p>#{Delorean::VERSION}</p>
-            </td>
-          </tr>
-          <tr>
-            <th scope="row">Mcfly</th>
-            <td class="overflow passed"><p>#{Mcfly::VERSION}</p>
-            </td>
-          </tr>
-          <tr>
-            <th scope="row">Git</th>
-            <td class="overflow passed"><p>#{git}</p>
-            </td>
-          </tr>
-        </table>
-      </div>
-      ERB
-    end
-
-    def version_display_fail val
-      <<-ERB
-      <h3>Version</h3>
-      <h3 class="error">Issues Detected </h3>
-      <div class="wrapper">
-      <table>
-         <tr>
-            <th></th>
-            <th scope="col">node1</th>
-            <th scope="col">node2</th>
-          </tr>
-          <tr>
-            <th scope="row">Marty</th>
-            <td class="overflow passed"><p>#{Marty::VERSION}</p></td>
-            <td class="overflow error"><p>#{val}</p></td>
-          </tr>
-          <tr>
-            <th scope="row">Delorean</th>
-            <td class="overflow passed"><p>#{Delorean::VERSION}</p></td>
-            <td class="overflow passed"><p>#{Delorean::VERSION}</p></td>
-          </tr>
-          <tr>
-            <th scope="row">Mcfly</th>
-            <td class="overflow passed"><p>#{Mcfly::VERSION}</p></td>
-            <td class="overflow passed"><p>#{Mcfly::VERSION}</p></td>
-          </tr>
-          <tr>
-            <th scope="row">Git</th>
-            <td class="overflow passed"><p>#{git}</p></td>
-            <td class="overflow passed"><p>#{git}</p></td>
-          </tr>
-      </table>
-      </div>
-      ERB
-    end
-
-    def minimize(str)
-      str.gsub(/\s+/, "")
-    end
-
     describe 'GET #op' do
-      it 'returns http success with local scope' do
-        get :op, op: 'version', scope: 'local'
+      it 'returns http success' do
+        get :op, format: :json, op: 'version'
         expect(response).to have_http_status(:success)
       end
 
-      it 'returns the current version JSON' do
-        get :op, format: :json, op: 'version', scope: 'local'
-        expect(assigns('result')).to eq(version)
+      it 'a request injects the request object into Diagnostic classes' do
+        get :op, format: :json, op: 'version'
+        expect(Diagnostic::Reporter.request).not_to eq(nil)
       end
 
-      it 'returns the correct environment JSON' do
-        get :op, format: :json, op: 'environment', scope: 'local'
-        expect(assigns('result')).to eq(environment)
-      end
-
-      it 'produces an html display of the diagnostic (version)' do
-        test = described_class::Version.display({'stub' => version})
-        expect(minimize(test)).to eq(minimize(version_display))
-      end
-
-      it 'masks consistent nodes for display (version)' do
-        data = {'node1' => version, 'node2' => version}
-        test = described_class::Version.display(data)
-        expect(minimize(test)).to eq(minimize(version_display))
-      end
-
-      it 'displays all nodes when there is an inconsistent node (version)' do
-        ver       = '0.0.0'
-        data      = {'node1' => version, 'node2' => version + {'Marty' => ver}}
-        expected  = version_display_fail(ver)
-        test      = described_class::Version.display(data)
-        expect(minimize(test)).to eq(minimize(expected))
-      end
-    end
-
-    describe 'diagnostic classes and aggregate functions' do
-      it 'has access to DiagnosticController request' do
-        get :op, op: 'version', scope: 'local'
-        expect(described_class::Base.request).not_to eq(nil)
-      end
-
-      it 'can aggregate diagnostics and return appropriate JSON' do
-        # simulate open-uri nodal diag request
-        uri_stub = {:open => nil, :readlines => [version.to_json]}
-        nodes    = ['node1', 'node2', 'node3']
-        expected = nodes.each_with_object({}){|n, h| h[n] = version}
-
-        # mock nodes and diag request to node
-        allow(described_class::Base.request).to receive(:port).and_return(3000)
-        allow(described_class::Base).to receive(:get_nodes).and_return(nodes)
-        allow(described_class::Base).to receive_message_chain(uri_stub)
+      it 'returns the current version JSON' do
+        get :op, format: :json, op: 'version', data: 'true'
 
-        # perform aggregation using Base class function and Version class
-        expect(described_class::Base.get_nodal_diags('version')).to eq(expected)
-        expect(described_class::Version.aggregate).to eq(expected)
-      end
+        # generate version data and declare all values consistent
+        versions = Diagnostic::Version.generate.each_with_object({}){
+          |(n, v),h|
+          h[n] = v.each{|t, r| r['consistent'] = true}
+        }
 
-      # returns true if there are differences in nodes for Base/Version
-      it 'determines diff of aggregate diagnostic' do
-        inconsistent = {'1' => version, '2' => version + {'Git' => '123'}}
-        consistent = inconsistent + {'2' => version}
-        aggregate_failures do
-          expect(described_class::Base.diff(inconsistent)).to eq(true)
-          expect(described_class::Base.diff(consistent)).to eq(false)
-          expect(described_class::Version.diff(inconsistent)).to eq(true)
-          expect(described_class::Version.diff(consistent)).to eq(false)
-        end
-      end
+        expected = {
+          'data' => {
+            'Diagnostic::Version' => versions
+          }
+        }
 
-      it 'can detects errors in diagnostic' do
-        error_free = version
-        error_test = version + {'Git' => described_class::Base.
-                                           error('Failed accessing git')}
-        aggregate_failures do
-          expect(described_class::Base.errors(error_free)).to eq(0)
-          expect(described_class::Base.errors(error_test)).to eq(1)
-          expect(described_class::Version.errors(error_free)).to eq(0)
-          expect(described_class::Version.errors(error_test)).to eq(1)
-        end
+        expect(assigns('result')).to eq(expected)
       end
     end
   end