flapjack 1.0.0rc1 → 1.0.0rc2

data/lib/flapjack/gateways/jabber.rb

@@ -50,9 +50,17 @@ module Flapjack
         @redis = Flapjack::RedisPool.new(:config => @redis_config, :size => 2)
 
         @logger = opts[:logger]
+        @logger.debug("Jabber Initializing")
 
         @buffer = []
         @hostname = Socket.gethostname
+
+        # FIXME: i suspect the following should be in #setup so a config reload updates @identifiers
+        # I moved it here so the rspec passes :-/
+        @alias = @config['alias'] || 'flapjack'
+        @identifiers = ((@config['identifiers'] || []) + [@alias]).uniq
+        @logger.debug("I will respond to the following identifiers: #{@identifiers.join(', ')}")
+
         super()
       end
 
@@ -65,7 +73,9 @@ module Flapjack
       end
 
       def setup
-        @flapjack_jid = Blather::JID.new((@config['jabberid'] || 'flapjack') + '/' + @hostname)
+        jid = @config['jabberid'] || 'flapjack'
+        jid += '/' + @hostname unless jid.include?('/')
+        @flapjack_jid = Blather::JID.new(jid)
 
         super(@flapjack_jid, @config['password'], @config['server'], @config['port'].to_i)
 
@@ -80,13 +90,19 @@ module Flapjack
           end
         end
 
-        register_handler :message, :groupchat?, :body => /^#{@config['alias']}:\s+/ do |stanza|
+        body_matchers = @identifiers.inject([]) do |memo, identifier|
+          @logger.debug("identifier: #{identifier}, memo: #{memo}")
+          memo << {:body => /^#{identifier}[:\s]/}
+          memo
+        end
+        @logger.debug("body_matchers: #{body_matchers}")
+        register_handler :message, :groupchat?, body_matchers do |stanza|
           EventMachine::Synchrony.next_tick do
             on_groupchat(stanza)
           end
         end
 
-        register_handler :message, :chat? do |stanza|
+        register_handler :message, :chat?, :body do |stanza|
           EventMachine::Synchrony.next_tick do
             on_chat(stanza)
           end
@@ -111,11 +127,11 @@ module Flapjack
             @logger.info("Joining room #{room}")
             presence = Blather::Stanza::Presence.new
             presence.from = @flapjack_jid
-            presence.to = Blather::JID.new("#{room}/#{@config['alias']}")
+            presence.to = Blather::JID.new("#{room}/#{@alias}")
             presence << "<x xmlns='http://jabber.org/protocol/muc'><history maxstanzas='0'></x>"
             EventMachine::Synchrony.next_tick do
               write presence
-              say(room, "flapjack jabber gateway started at #{Time.now}, hello!", :groupchat)
+              say(room, "flapjack jabber gateway started at #{Time.now}, hello! Try typing 'help'.", :groupchat)
             end
           end
         end
@@ -160,7 +176,7 @@ module Flapjack
         out
       end
 
-      def interpreter(command_raw,from)
+      def interpreter(command_raw, from)
         msg          = nil
         action       = nil
         entity_check = nil
@@ -239,7 +255,8 @@ module Flapjack
           t    = Process.times
           fqdn = `/bin/hostname -f`.chomp
           pid  = Process.pid
-          msg  = "Flapjack #{Flapjack::VERSION} process #{pid} on #{fqdn} \n" +
+          msg  = "Flapjack #{Flapjack::VERSION} process #{pid} on #{fqdn}\n" +
+                 "Identifiers: #{@identifiers.join(', ')}\n" +
                  "Boot time: #{@boot_time}\n" +
                  "User CPU Time: #{t.utime}\n" +
                  "System CPU Time: #{t.stime}\n" +
@@ -537,18 +554,23 @@ module Flapjack
         return if @should_quit
         @logger.debug("groupchat message received: #{stanza.inspect}")
 
-        if stanza.body =~ /^#{@config['alias']}:\s+(.*)/m
-          command  = $1
+        the_command = nil
+        @identifiers.each do |identifier|
+          if stanza.body =~ /^#{identifier}:?\s*(.*)/m
+            the_command  = $1
+            @logger.debug("matched identifier: #{identifier}, command: #{the_command.inspect}")
+            break
+          end
         end
 
         from = stanza.from
 
         begin
-          results = interpreter(command, from.resource.to_s)
+          results = interpreter(the_command, from.to_s)
           msg     = results[:msg]
           action  = results[:action]
         rescue => e
-          @logger.error("Exception when interpreting command '#{command}' - #{e.class}, #{e.message}")
+          @logger.debug("Exception when interpreting command '#{the_command}' - #{e.class}, #{e.message}")
           msg = "Oops, something went wrong processing that command (#{e.class}, #{e.message})"
         end
 
@@ -571,8 +593,10 @@ module Flapjack
           command = stanza.body
         end
 
+        from = stanza.from
+
         begin
-          results = interpreter(command)
+          results = interpreter(command, from.resource.to_s)
           msg     = results[:msg]
           action  = results[:action]
         rescue => e

data/lib/flapjack/gateways/jsonapi/check_methods.rb

@@ -31,6 +31,38 @@ module Flapjack
           app.helpers Flapjack::Gateways::JSONAPI::Helpers
           app.helpers Flapjack::Gateways::JSONAPI::CheckMethods::Helpers
 
+          app.get %r{^/checks(?:/)?(.+)?$} do
+            requested_checks = if params[:captures] && params[:captures][0]
+              params[:captures][0].split(',').uniq
+            else
+              nil
+            end
+
+            checks = if requested_checks
+              requested_checks.collect do|req_check|
+                Flapjack::Data::EntityCheck.for_event_id(req_check, :logger => logger, :redis => redis)
+              end
+            else
+              Flapjack::Data::EntityCheck.find_all(:redis => redis)
+            end
+            checks.compact!
+
+            if requested_checks && checks.empty?
+              raise Flapjack::Gateways::JSONAPI::ChecksNotFound.new(requested_checks)
+            end
+
+            linked_entity_ids = checks.empty? ? [] : checks.inject({}) do |memo, check|
+              memo[check.key] = check.entity.id
+              memo
+            end
+
+            checks_json = checks.collect {|check|
+              check.to_jsonapi(:entity_ids => linked_entity_ids[check.key])
+            }.join(",")
+
+            '{"checks":[' + checks_json + ']}'
+          end
+
           app.patch %r{^/checks/(.+)$} do
             checks_for_check_names(params[:captures][0].split(',')).each do |check|
               apply_json_patch('checks') do |op, property, linked, value|

data/lib/flapjack/gateways/jsonapi/report_methods.rb

@@ -27,11 +27,7 @@ module Flapjack
             end
 
             checks = if event_ids.nil?
-              Flapjack::Data::Entity.all(:redis => redis).collect {|entity|
-                entity.check_list.collect {|check_name|
-                  find_entity_check(entity, check_name)
-                }
-              }.flatten(2)
+              Flapjack::Data::EntityCheck.find_all(:redis => redis)
             elsif !event_ids.empty?
               event_ids.collect {|event_id| find_entity_check_by_name(*event_id.split(':', 2)) }
             else

data/lib/flapjack/gateways/web/views/check.html.erb

@@ -4,7 +4,7 @@
   current_time = Time.now
 %>
 <div class="page-header">
-  <% entity_link = u(@base_url) + "entity/" << u(@entity) %>
+  <% entity_link = @base_url + "entity/" << u(@entity) %>
   <h2><%= h @check %> on <a href="<%= entity_link %>" title="entity summary"><%= h @entity %></a></h2>
 </div>
 

data/lib/flapjack/gateways/web/views/checks.html.erb

@@ -21,7 +21,7 @@
   <tbody>
     <% @entities_sorted.each do |entity| %>
       <% row_entity = nil %>
-      <% entity_link = u(@base_url) + "entity/" << u(entity) %>
+      <% entity_link = @base_url + "entity/" << u(entity) %>
       <% @states[entity].each do |check, status, summary, changed, updated, in_unscheduled_outage, in_scheduled_outage, notified| %>
         <%
           row_colour = case status
@@ -33,7 +33,7 @@
             status
           end
 
-          check_link = u(@base_url) + "check?entity=" << u(entity) << "&amp;check=" << u(check)
+          check_link = @base_url + "check?entity=" << u(entity) << "&amp;check=" << u(check)
         %>
         <tr class="<%= row_colour %>">
         <% unless row_entity && entity == row_entity %>

data/lib/flapjack/gateways/web/views/contact.html.erb

@@ -81,7 +81,7 @@
           <td>
             <% checks.each do |entity_check| %>
               <% entity, check = entity_check.split(':', 2) %>
-              <% check_link = "<a href=\"#{u(@base_url)}check?entity=#{u(entity)}&amp;check=#{u(check)}\" title=\"check status\">" +
+              <% check_link = "<a href=\"#{@base_url}check?entity=#{u(entity)}&amp;check=#{u(check)}\" title=\"check status\">" +
                  h(check) + "</a>"%>
               <a href="<%= @base_url %>entity/<%= u(entity) %>" title="entity status"><%= h entity %></a> ::
               <%= check_link %> <br />
@@ -147,7 +147,7 @@
         <td><a href="<%= @base_url %>entity/<%= u(entity.name) %>" title="entity status"><%= h entity.name %></a></td>
         <td>
           <% checks.each do |check| %>
-          <%= "<a href=\"#{u(@base_url)}check?entity=#{u(entity.name)}&amp;check=#{u(check)}\" title=\"check status\">#{ h check }</a>" %>
+          <%= "<a href=\"#{@base_url}check?entity=#{u(entity.name)}&amp;check=#{u(check)}\" title=\"check status\">#{ h check }</a>" %>
           <% end %>
         </td>
       </tr>

data/lib/flapjack/gateways/web/views/entity.html.erb

@@ -28,7 +28,7 @@
           status
         end
 
-        check_link = u(@base_url) + "check?entity=" << u(@entity) << "&amp;check=" << u(check)
+        check_link = @base_url + "check?entity=" << u(@entity) << "&amp;check=" << u(check)
 
       %>
       <tr class="<%= row_colour %>">

data/lib/flapjack/patches.rb

@@ -116,3 +116,73 @@ class Redis
     end
   end
 end
+
+module GLI
+  class Command
+    attr_accessor :passthrough
+    def _action
+      @action
+    end
+  end
+
+  class GLIOptionParser
+    class NormalCommandOptionParser
+      def parse!(parsing_result)
+        parsed_command_options = {}
+        command = parsing_result.command
+        arguments = nil
+
+        loop do
+          command._action.call if command.passthrough
+
+          option_parser_factory       = OptionParserFactory.for_command(command,@accepts)
+          option_block_parser         = CommandOptionBlockParser.new(option_parser_factory, self.error_handler)
+          option_block_parser.command = command
+          arguments                   = parsing_result.arguments
+
+          arguments = option_block_parser.parse!(arguments)
+
+          parsed_command_options[command] = option_parser_factory.options_hash_with_defaults_set!
+          command_finder                  = CommandFinder.new(command.commands,command.get_default_command)
+          next_command_name               = arguments.shift
+
+          verify_required_options!(command.flags,parsed_command_options[command])
+
+          begin
+            command = command_finder.find_command(next_command_name)
+          rescue AmbiguousCommand
+            arguments.unshift(next_command_name)
+            break
+          rescue UnknownCommand
+            arguments.unshift(next_command_name)
+            # Although command finder could certainy know if it should use
+            # the default command, it has no way to put the "unknown command"
+            # back into the argument stack.  UGH.
+            unless command.get_default_command.nil?
+              command = command_finder.find_command(command.get_default_command)
+            end
+            break
+          end
+        end
+
+        parsed_command_options[command] ||= {}
+        command_options = parsed_command_options[command]
+
+        this_command          = command.parent
+        child_command_options = command_options
+
+        while this_command.kind_of?(command.class)
+          this_command_options = parsed_command_options[this_command] || {}
+          child_command_options[GLI::Command::PARENT] = this_command_options
+          this_command = this_command.parent
+          child_command_options = this_command_options
+        end
+
+        parsing_result.command_options = command_options
+        parsing_result.command = command
+        parsing_result.arguments = Array(arguments.compact)
+        parsing_result
+      end
+    end
+  end
+end

data/lib/flapjack/version.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
 module Flapjack
-  VERSION = "1.0.0rc1"
+  VERSION = "1.0.0rc2"
 end
 

data/libexec/httpbroker.go

@@ -0,0 +1,161 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"io/ioutil"
+	"time"
+	"net/http"
+	"flapjack"
+	"encoding/json"
+	"gopkg.in/alecthomas/kingpin.v1"
+	"github.com/go-martini/martini"
+)
+
+// State is a basic representation of a Flapjack event, with some extra field.
+// The extra fields handle state expiry.
+// Find more at https://github.com/flapjack/flapjack/wiki/DATA_STRUCTURES
+type State struct {
+	flapjack.Event
+	TTL	int64  `json:"ttl"`
+}
+
+// handler caches
+func CreateState(updates chan State, w http.ResponseWriter, r *http.Request) {
+	var state State
+
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		message := "Error: Couldn't read request body: %s\n"
+		log.Printf(message, err)
+		fmt.Fprintf(w, message, err)
+		return
+	}
+
+	err = json.Unmarshal(body, &state)
+	if err != nil {
+		message := "Error: Couldn't read request body: %s\n"
+		log.Println(message, err)
+		fmt.Fprintf(w, message, err)
+		return
+	}
+
+	// Populate a time if none has been set.
+	if state.Time == 0 {
+		state.Time = time.Now().Unix()
+	}
+
+	if len(state.Type) == 0 {
+		state.Type = "service"
+	}
+
+	if state.TTL == 0 {
+		state.TTL = 300
+	}
+
+	updates <- state
+
+	json, _ := json.Marshal(state)
+	message := "Caching state: %s\n"
+	log.Printf(message, json)
+	fmt.Fprintf(w, message, json)
+}
+
+// cacheState stores a cache of event state to be sent to Flapjack.
+// The event state is queried later when submitting events periodically
+// to Flapjack.
+func cacheState(updates chan State, state map[string]State) {
+	for ns := range updates {
+		key := ns.Entity + ":" + ns.Check
+		state[key] = ns
+	}
+}
+
+// submitCachedState periodically samples the cached state, sends it to Flapjack.
+func submitCachedState(states map[string]State, config Config) {
+	transport, err := flapjack.Dial(config.Server, config.Database)
+	if err != nil {
+		fmt.Printf("Error: %s\n", err)
+		os.Exit(1)
+	}
+
+	for {
+		log.Printf("Number of cached states: %d\n", len(states))
+		for id, state := range(states) {
+			now := time.Now().Unix()
+			event := flapjack.Event{
+				Entity:  state.Entity,
+				Check:   state.Check,
+				Type:    state.Type,
+				State:   state.State,
+				Summary: state.Summary,
+				Time:    now,
+			}
+
+			// Stale state sends UNKNOWNs
+			elapsed := now - state.Time
+			if state.TTL >= 0 && elapsed > state.TTL {
+				log.Printf("State for %s is stale. Sending UNKNOWN.\n", id)
+				event.State = "UNKNOWN"
+				event.Summary = fmt.Sprintf("httpbroker: Cached state is stale (%ds old, should be < %ds)", elapsed, state.TTL)
+			}
+			if config.Debug {
+				log.Printf("Sending event data for %s\n", id)
+			}
+			transport.Send(event)
+		}
+		time.Sleep(config.Interval)
+	}
+}
+
+var (
+	port		= kingpin.Flag("port", "Address to bind HTTP server (default 3090)").Default("3090").OverrideDefaultFromEnvar("PORT").String()
+	server		= kingpin.Flag("server", "Redis server to connect to (default localhost:6380)").Default("localhost:6380").String()
+	database	= kingpin.Flag("database", "Redis database to connect to (default 0)").Int() // .Default("13").Int()
+	interval	= kingpin.Flag("interval", "How often to submit events (default 10s)").Default("10s").Duration()
+	debug		= kingpin.Flag("debug", "Enable verbose output (default false)").Bool()
+)
+
+type Config struct {
+	Port		string
+	Server		string
+	Database	int
+	Interval	time.Duration
+	Debug		bool
+}
+
+func main() {
+	kingpin.Version("0.0.1")
+	kingpin.Parse()
+
+	config := Config{
+		Server: 	*server,
+		Database: 	*database,
+		Interval: 	*interval,
+		Debug:		*debug,
+		Port: 		":" + *port,
+	}
+	if config.Debug {
+		log.Printf("Booting with config: %+v\n", config)
+	}
+
+	updates := make(chan State)
+	state := map[string]State{}
+
+	go cacheState(updates, state)
+	go submitCachedState(state, config)
+
+	m := martini.Classic()
+	m.Group("/state", func(r martini.Router) {
+		r.Post("", func(res http.ResponseWriter, req *http.Request) {
+			CreateState(updates, res, req)
+		})
+		r.Get("", func() []byte {
+			data, _ := json.Marshal(state)
+			return data
+		})
+	})
+
+	log.Fatal(http.ListenAndServe(config.Port, m))
+}