sensu-dashboard 0.9.4 → 0.9.6.beta

data/lib/sensu-dashboard/app.rb

@@ -1,448 +1,464 @@
-require 'eventmachine'
-require 'sinatra/async'
+require 'sensu/config'
 require 'em-http-request'
 require 'em-websocket'
+require 'sinatra/async'
 require 'sass'
-require 'json'
-require 'sensu/config'
-
-options = Sensu::Config.read_arguments(ARGV)
-config = Sensu::Config.new(options)
-SETTINGS = config.settings
 
-EventMachine.run do
+class Dashboard < Sinatra::Base
+  register Sinatra::Async
 
-  class DashboardServer < Sinatra::Base
+  def self.run(options={})
+    EM::run do
+      self.setup(options)
+      self.websocket_server
+      self.run!(:port => $settings.dashboard.port)
 
-    register Sinatra::Async
-    set :root, File.dirname(__FILE__)
-    set :static, true
-    set :public_folder, Proc.new { File.join(root, "public") }
-
-    api_server = 'http://' + SETTINGS['api']['host'] + ':' + SETTINGS['api']['port'].to_s
-
-    use Rack::Auth::Basic do |user, password|
-      user == SETTINGS['dashboard']['user'] && password == SETTINGS['dashboard']['password']
+      %w[INT TERM].each do |signal|
+        Signal.trap(signal) do
+          self.stop(signal)
+        end
+      end
     end
+  end
 
-    before do
-      content_type 'application/json'
+  def self.setup(options={})
+    config = Sensu::Config.new(options)
+    $settings = config.settings
+    $logger = config.logger || config.open_log
+    unless $settings.key?('dashboard')
+      raise config.invalid_config('missing the following key: dashboard')
     end
-
-    aget '/' do
-      content_type 'text/html'
-      @js = erb :event_templates, :layout => false
-      body erb :index
+    unless $settings.dashboard.port.is_a?(Integer)
+      raise config.invalid_config('dashboard must have a port')
     end
-
-    aget '/clients' do
-      content_type 'text/html'
-      @js = erb :client_templates, :layout => false
-      body erb :clients
+    unless $settings.dashboard.user.is_a?(String) && $settings.dashboard.password.is_a?(String)
+      raise config.invalid_config('dashboard must have a user and password')
     end
-
-    aget '/stashes' do
-      content_type 'text/html'
-      @js = erb :stash_templates, :layout => false
-      body erb :stashes
+    if options[:daemonize]
+      Process.daemonize
     end
-
-    aget '/css/sonian.css' do
-      content_type 'text/css'
-      body sass :sonian
+    if options[:pid_file]
+      Process.write_pid(options[:pid_file])
     end
+    $api_server = 'http://' + $settings.api.host + ':' + $settings.api.port.to_s
+  end
 
-    # api proxy
-    aget '/events.json' do
-      begin
-        http = EventMachine::HttpRequest.new("#{api_server}/events").get
-      rescue => e
-        puts e
-        status 404
-        body '{"error":"could not retrieve events from the sensu api"}'
-      end
-
-      http.errback do
-        status 404
-        body '{"error":"could not retrieve events from the sensu api"}'
+  def self.websocket_server
+    $websocket_connections = []
+    EM::WebSocket.start(:host => '0.0.0.0', :port => 9000) do |websocket|
+      websocket.onopen do
+        $logger.info('[websocket] -- client connected to websocket')
+        $websocket_connections.push(websocket)
       end
-
-      http.callback do
-        status http.response_header.status
-        body http.response
+      websocket.onclose do
+        $logger.info('[websocket] -- client disconnected from websocket')
+        $websocket_connections.delete(websocket)
       end
     end
+  end
 
-    # api proxy
-    aget '/autocomplete.json' do
-      multi = EventMachine::MultiRequest.new
-
-      requests = [
-        "#{api_server}/events",
-        "#{api_server}/clients"
-      ]
+  set :root, File.dirname(__FILE__)
+  set :static, true
+  set :public_folder, Proc.new { File.join(root, 'public') }
 
-      requests.each do |url|
-        multi.add EventMachine::HttpRequest.new(url).get
-      end
+  use Rack::Auth::Basic do |user, password|
+    user == $settings.dashboard.user && password == $settings.dashboard.password
+  end
 
-      multi.callback do
-        events = {}
-        clients = []
-
-        multi.responses[:succeeded].each do |request|
-          body = JSON.parse(request.response)
-          case body
-          when Hash
-            events = body
-          when Array
-            clients = body
-          end
-        end
+  before do
+    content_type 'application/json'
+  end
 
-        if events && clients
-          autocomplete = []
-          statuses = {:warning => [], :critical => [], :unknown => []}
-          subscriptions = {}
-          checks = []
-
-          # searching by client
-          clients.each do |client|
-            client_name = client['name']
-            if events.include?(client_name)
-              autocomplete.push({:value => [client_name], :type => 'client', :name => client_name})
-              client['subscriptions'].each do |subscription|
-                subscriptions[subscription] ||= []
-                subscriptions[subscription].push(client_name)
-              end
-              events[client_name].each do |check, event|
-                
-                case event['status']
-                when 1
-                  statuses[:warning].push(event['status'])
-                when 2
-                  statuses[:critical].push(event['status'])
-                else
-                  statuses[:unknown].push(event['status'])
-                end
-                checks.push(check)
-              end
-            end
-          end
+  aget '/' do
+    content_type 'text/html'
+    @js = erb :event_templates, :layout => false
+    body erb :index
+  end
 
-          # searching by subscription
-          subscriptions.each do |k, v|
-            autocomplete.push({:value => v.uniq, :type => 'subscription', :name => k})
-          end
+  aget '/clients' do
+    content_type 'text/html'
+    @js = erb :client_templates, :layout => false
+    body erb :clients
+  end
 
-          # searching by status
-          statuses.each do |k, v|
-            autocomplete.push({:value => v.uniq, :type => 'status', :name => k})
-          end
+  aget '/stashes' do
+    content_type 'text/html'
+    @js = erb :stash_templates, :layout => false
+    body erb :stashes
+  end
 
-          # searching by check
-          checks.uniq.each do |v|
-            autocomplete.push({:value => [v], :type => 'check', :name => v})
-          end
+  aget '/css/sonian.css' do
+    content_type 'text/css'
+    body sass :sonian
+  end
 
-          body autocomplete.to_json
-        else
-          status 404
-          body '{"error":"could not retrieve events and/or clients from the sensu api"}'
-        end
+  apost '/events.json' do
+    $logger.debug('[events] -- ' + request.ip + ' -- POST -- triggering dashboard refresh')
+    unless $websocket_connections.empty?
+      $websocket_connections.each do |websocket|
+        websocket.send '{"update":"true"}'
       end
     end
+    body '{"success":"triggered dashboard refresh"}'
+  end
 
-    aget '/clients.json' do
-      begin
-        http = EventMachine::HttpRequest.new("#{api_server}/clients").get
-      rescue => e
-        puts e
-        status 404
-        body '{"error":"could not retrieve clients from the sensu api"}'
-      end
+  aget '/autocomplete.json' do
+    multi = EM::MultiRequest.new
 
-      http.errback do
-        status 404
-        body '{"error":"could not retrieve clients from the sensu api"}'
-      end
+    requests = [
+      $api_server + '/events',
+      $api_server + '/clients'
+    ]
 
-      http.callback do
-        status http.response_header.status
-        body http.response
-      end
+    requests.each do |url|
+      multi.add EM::HttpRequest.new(url).get
     end
 
-    # api proxy
-    aget '/clients/autocomplete.json' do
-      multi = EventMachine::MultiRequest.new
-
-      requests = [
-        "#{api_server}/clients"
-      ]
-
-      requests.each do |url|
-        multi.add EventMachine::HttpRequest.new(url).get
-      end
-
-      multi.callback do
-        events = {}
-        clients = []
-
-        multi.responses[:succeeded].each do |request|
-          body = JSON.parse(request.response)
-          case body
-          when Array
-            clients = body
-          end
+    multi.callback do
+      events = {}
+      clients = []
+
+      multi.responses[:succeeded].each do |request|
+        body = JSON.parse(request.response)
+        case body
+        when Hash
+          events = body
+        when Array
+          clients = body
         end
+      end
 
-        if clients
-          autocomplete = []
-          subscriptions = {}
+      if events && clients
+        autocomplete = []
+        statuses = {:warning => [], :critical => [], :unknown => []}
+        subscriptions = {}
+        checks = []
 
-          # searching by client
-          clients.each do |client|
-            client_name = client['name']
+        # searching by client
+        clients.each do |client|
+          client_name = client['name']
+          if events.include?(client_name)
             autocomplete.push({:value => [client_name], :type => 'client', :name => client_name})
             client['subscriptions'].each do |subscription|
               subscriptions[subscription] ||= []
               subscriptions[subscription].push(client_name)
             end
+            events[client_name].each do |check, event|
+              case event['status']
+              when 1
+                statuses[:warning].push(event['status'])
+              when 2
+                statuses[:critical].push(event['status'])
+              else
+                statuses[:unknown].push(event['status'])
+              end
+              checks.push(check)
+            end
           end
+        end
 
-          # searching by subscription
-          subscriptions.each do |k, v|
-            autocomplete.push({:value => v.uniq, :type => 'subscription', :name => k})
-          end
+        # searching by subscription
+        subscriptions.each do |k, v|
+          autocomplete.push({:value => v.uniq, :type => 'subscription', :name => k})
+        end
 
-          body autocomplete.to_json
-        else
-          status 404
-          body '{"error":"could not retrieve clients from the sensu api"}'
+        # searching by status
+        statuses.each do |k, v|
+          autocomplete.push({:value => v.uniq, :type => 'status', :name => k})
         end
-      end
-    end
 
-    aget '/client/:id.json' do |id|
-      begin
-        http = EventMachine::HttpRequest.new("#{api_server}/client/#{id}").get
-      rescue => e
-        puts e
-        status 404
-        body '{"error":"could not retrieve client from the sensu api"}'
-      end
+        # searching by check
+        checks.uniq.each do |v|
+          autocomplete.push({:value => [v], :type => 'check', :name => v})
+        end
 
-      http.errback do
+        body autocomplete.to_json
+      else
         status 404
-        body '{"error":"could not retrieve client from the sensu api"}'
+        body '{"error":"could not retrieve events and/or clients from the sensu api"}'
       end
+    end
+  end
 
-      http.callback do
-        status http.response_header.status
-        body http.response
-      end
+  aget '/clients/autocomplete.json' do
+    multi = EM::MultiRequest.new
+
+    requests = [
+     $api_server + '/clients'
+    ]
+
+    requests.each do |url|
+      multi.add EM::HttpRequest.new(url).get
     end
 
-    adelete '/client/:id.json' do |id|
-      begin
-        http = EventMachine::HttpRequest.new("#{api_server}/client/#{id}").delete
-      rescue => e
-        puts e
-        status 404
-        body '{"error":"could not delete client from the sensu api"}'
+    multi.callback do
+      events = {}
+      clients = []
+
+      multi.responses[:succeeded].each do |request|
+        body = JSON.parse(request.response)
+        case body
+        when Array
+          clients = body
+        end
       end
 
-      http.errback do
+      if clients
+        autocomplete = []
+        subscriptions = {}
+
+        # searching by client
+        clients.each do |client|
+          client_name = client['name']
+          autocomplete.push({:value => [client_name], :type => 'client', :name => client_name})
+          client['subscriptions'].each do |subscription|
+            subscriptions[subscription] ||= []
+            subscriptions[subscription].push(client_name)
+          end
+        end
+
+        # searching by subscription
+        subscriptions.each do |k, v|
+          autocomplete.push({:value => v.uniq, :type => 'subscription', :name => k})
+        end
+
+        body autocomplete.to_json
+      else
         status 404
-        body '{"error":"could not delete client from the sensu api"}'
+        body '{"error":"could not retrieve clients from the sensu api"}'
       end
+    end
+  end
 
-      http.callback do
-        status http.response_header.status
-        body http.response
-      end
+  #
+  # API Proxy
+  #
+
+  aget '/events.json' do
+    begin
+      http = EM::HttpRequest.new($api_server + '/events').get
+    rescue => e
+      $logger.warning(e)
+      status 404
+      body '{"error":"could not retrieve events from the sensu api"}'
     end
 
-    aget '/stash/*.json' do |path|
-      begin
-        http = EventMachine::HttpRequest.new("#{api_server}/stash/#{path}").get
-      rescue => e
-        puts e
-        status 404
-        body '{"error":"could not retrieve a stash from the sensu api"}'
-      end
+    http.errback do
+      status 404
+      body '{"error":"could not retrieve events from the sensu api"}'
+    end
 
-      http.errback do
-        status 404
-        body '{"error":"could not retrieve a stash from the sensu api"}'
-      end
+    http.callback do
+      status http.response_header.status
+      body http.response
+    end
+  end
 
-      http.callback do
-        status http.response_header.status
-        body http.response
-      end
+  aget '/clients.json' do
+    begin
+      http = EM::HttpRequest.new($api_server + '/clients').get
+    rescue => e
+      $logger.warning(e)
+      status 404
+      body '{"error":"could not retrieve clients from the sensu api"}'
     end
 
-    apost '/stash/*.json' do |path|
-      begin
-        request_options = {
-          :body => {'timestamp' => Time.now.to_i}.to_json,
-          :head => {
-            'content-type' => 'application/json'
-          }
-        }
-        http = EventMachine::HttpRequest.new("#{api_server}/stash/#{path}").post request_options
-      rescue => e
-        puts e
-        status 404
-        body '{"error":"could not create a stash with the sensu api"}'
-      end
+    http.errback do
+      status 404
+      body '{"error":"could not retrieve clients from the sensu api"}'
+    end
 
-      http.errback do
-        status 404
-        body '{"error":"could not create a stash with the sensu api"}'
-      end
+    http.callback do
+      status http.response_header.status
+      body http.response
+    end
+  end
 
-      http.callback do
-        status http.response_header.status
-        body http.response
-      end
+  aget '/client/:id.json' do |id|
+    begin
+      http = EM::HttpRequest.new($api_server + '/client/' + id).get
+    rescue => e
+      $logger.warning(e)
+      status 404
+      body '{"error":"could not retrieve client from the sensu api"}'
     end
 
-    adelete '/stash/*.json' do |path|
-      begin
-        http = EventMachine::HttpRequest.new("#{api_server}/stash/#{path}").delete
-      rescue => e
-        puts e
-        status 404
-        body '{"error":"could not delete a stash with the sensu api"}'
-      end
+    http.errback do
+      status 404
+      body '{"error":"could not retrieve client from the sensu api"}'
+    end
 
-      http.errback do
-        status 404
-        body '{"error":"could not delete a stash with the sensu api"}'
-      end
+    http.callback do
+      status http.response_header.status
+      body http.response
+    end
+  end
 
-      http.callback do
-        status http.response_header.status
-        body http.response
-      end
+  adelete '/client/:id.json' do |id|
+    begin
+      http = EventMachine::HttpRequest.new($api_server + '/client/' + id).delete
+    rescue => e
+      $logger.warning(e)
+      status 404
+      body '{"error":"could not delete client from the sensu api"}'
     end
 
-    apost '/event/resolve.json' do
-      begin
-        request_options = {
-          :body => request.body.read,
-          :head => {
-            'content-type' => 'application/json'
-          }
-        }
-        http = EventMachine::HttpRequest.new("#{api_server}/event/resolve").post request_options
-      rescue => e
-        puts e
-        status 404
-        body '{"error":"could not resolve an event with the sensu api"}'
-      end
+    http.errback do
+      status 404
+      body '{"error":"could not delete client from the sensu api"}'
+    end
 
-      http.errback do
-        status 404
-        body '{"error":"could not resolve an event with the sensu api"}'
-      end
+    http.callback do
+      status http.response_header.status
+      body http.response
+    end
+  end
 
-      http.callback do
-        status http.response_header.status
-        body http.response
-      end
+  aget '/stash/*.json' do |path|
+    begin
+      http = EM::HttpRequest.new($api_server + '/stash/' + path).get
+    rescue => e
+      $logger.warning(e)
+      status 404
+      body '{"error":"could not retrieve a stash from the sensu api"}'
+    end
+
+    http.errback do
+      status 404
+      body '{"error":"could not retrieve a stash from the sensu api"}'
     end
 
-    aget '/stashes.json' do
-      begin
-        request_options = {
-#          :body => request.body.read,
-          :head => {
-            'content-type' => 'application/json'
-          }
+    http.callback do
+      status http.response_header.status
+      body http.response
+    end
+  end
+
+  apost '/stash/*.json' do |path|
+    begin
+      request_options = {
+        :body => {'timestamp' => Time.now.to_i}.to_json,
+        :head => {
+          'content-type' => 'application/json'
         }
-        http = EventMachine::HttpRequest.new("#{api_server}/stashes").get request_options
-      rescue => e
-        puts e
-        status 404
-        body '{"error":"could not retrieve a list of stashes from the sensu api"}'
-      end
+      }
+      http = EM::HttpRequest.new($api_server + '/stash/' + path).post request_options
+    rescue => e
+      $logger.warning(e)
+      status 404
+      body '{"error":"could not create a stash with the sensu api"}'
+    end
 
-      http.errback do
-        status 404
-        body '{"error":"could not retrieve a list of stashes from the sensu api"}'
-      end
+    http.errback do
+      status 404
+      body '{"error":"could not create a stash with the sensu api"}'
+    end
 
-      http.callback do
-        resp = http.response
-        status http.response_header.status
-        body resp
-      end
+    http.callback do
+      status http.response_header.status
+      body http.response
     end
+  end
 
-    apost '/stashes.json' do
-      begin
-        request_options = {
-          :body => request.body.read,
-          :head => {
-            'content-type' => 'application/json'
-          }
-        }
-        http = EventMachine::HttpRequest.new("#{api_server}/stashes").post request_options
-      rescue => e
-        puts e
-        status 404
-        body '{\"error\":\"could not retrieve a list of stashes from the sensu api\"}'
-      end
+  adelete '/stash/*.json' do |path|
+    begin
+      http = EM::HttpRequest.new($api_server + '/stash/' + path).delete
+    rescue => e
+      $logger.warning(e)
+      status 404
+      body '{"error":"could not delete a stash with the sensu api"}'
+    end
 
-      http.errback do
-        status 404
-        body '{\"error\":\"could not retrieve a list of stashes from the sensu api\"}'
-      end
+    http.errback do
+      status 404
+      body '{"error":"could not delete a stash with the sensu api"}'
+    end
 
-      http.callback do
-        resp = http.response
-        puts resp
-        status http.response_header.status
-        body resp
-      end
+    http.callback do
+      status http.response_header.status
+      body http.response
     end
+  end
 
-    websocket_connections = Array.new
-    EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 9000) do |websocket|
-      websocket.onopen do
-        websocket_connections.push websocket
-        puts 'client connected to websocket'
-      end
-      websocket.onclose do
-        websocket_connections.delete websocket
-        puts 'client disconnected from websocket'
-      end
+  apost '/event/resolve.json' do
+    begin
+      request_options = {
+        :body => request.body.read,
+        :head => {
+          'content-type' => 'application/json'
+        }
+      }
+      http = EM::HttpRequest.new($api_server + '/event/resolve').post request_options
+    rescue => e
+      $logger.warning(e)
+      status 404
+      body '{"error":"could not resolve an event with the sensu api"}'
     end
 
-    apost '/events.json' do
-      unless websocket_connections.empty?
-        websocket_connections.each do |websocket|
-          websocket.send '{"update":"true"}'
-        end
-      end
-      body '{"success":"triggered dashboard refresh"}'
+    http.errback do
+      status 404
+      body '{"error":"could not resolve an event with the sensu api"}'
+    end
+
+    http.callback do
+      status http.response_header.status
+      body http.response
     end
   end
 
-  DashboardServer.run!({:port => SETTINGS['dashboard']['port']})
+  aget '/stashes.json' do
+    begin
+      http = EM::HttpRequest.new($api_server + '/stashes').get
+    rescue => e
+      $logger.warning(e)
+      status 404
+      body '{"error":"could not retrieve a list of stashes from the sensu api"}'
+    end
 
-  #
-  # Recognize exit command
-  #
-  Signal.trap("INT") do
-    EM.stop
+    http.errback do
+      status 404
+      body '{"error":"could not retrieve a list of stashes from the sensu api"}'
+    end
+
+    http.callback do
+      status http.response_header.status
+      body http.response
+    end
   end
-  Signal.trap("TERM") do
-    EM.stop
+
+  apost '/stashes.json' do
+    begin
+      request_options = {
+        :body => request.body.read,
+        :head => {
+          'content-type' => 'application/json'
+        }
+      }
+      http = EM::HttpRequest.new($api_server + '/stashes').post request_options
+    rescue => e
+      $logger.warning(e)
+      status 404
+      body '{"error":"could not retrieve a list of stashes from the sensu api"}'
+    end
+
+    http.errback do
+      status 404
+      body '{"error":"could not retrieve a list of stashes from the sensu api"}'
+    end
+
+    http.callback do
+      status http.response_header.status
+      body http.response
+    end
   end
 
+  def self.stop(signal)
+    $logger.warn('[stop] -- stopping sensu dashboard -- ' + signal)
+    EM::Timer.new(1) do
+      EM::stop_event_loop
+    end
+  end
 end
+
+options = Sensu::Config.read_arguments(ARGV)
+Dashboard.run(options)

data/lib/sensu-dashboard/public/js/functions.js

@@ -261,7 +261,7 @@ function fetchStashes() {
     type: 'GET',
     url: '/stashes.json',
     success: function(data, textStatus, xhr) {
-      if (data.legnth > 0) {
+      if (data.length > 0) {
         $.ajax({
           type: 'POST',
           url: '/stashes.json',

data/lib/sensu-dashboard/version.rb

@@ -1,5 +1,5 @@
 module Sensu
   module Dashboard
-    VERSION = "0.9.4"
+    VERSION = "0.9.6.beta"
   end
 end

data/lib/sensu-dashboard/views/stashes.erb

@@ -5,8 +5,8 @@
     <thead>
 
       <tr>
-        <td class="col_clients">Path</td>
-        <td class="col_checks">Keys</td>
+        <th class="col_clients">Path</th>
+        <th class="col_checks">Keys</th>
       </tr>
 
     </thead>

data/sensu-dashboard.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.summary     = %q{A web interface for sensu, a publish/subscribe server monitoring framework}
   s.description = %q{Display current events and clients in sensu via a simple web interface}
 
-  s.add_dependency("sensu")
+  s.add_dependency("sensu", "~> 0.9.1")
   s.add_dependency("em-http-request", "0.3.0")
   s.add_dependency("em-websocket")
   s.add_dependency("sass")

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: sensu-dashboard
 version: !ruby/object:Gem::Version 
-  hash: 51
-  prerelease: false
+  hash: 31098129
+  prerelease: true
   segments: 
   - 0
   - 9
-  - 4
-  version: 0.9.4
+  - 6
+  - beta
+  version: 0.9.6.beta
 platform: ruby
 authors: 
 - Justin Kolberg
@@ -25,12 +26,14 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 57
         segments: 
         - 0
-        version: "0"
+        - 9
+        - 1
+        version: 0.9.1
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -149,12 +152,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: