flapjack 0.6.39 → 0.6.40

data/lib/flapjack/persistence/data_mapper/models/check_template.rb

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-
-class CheckTemplate
-  include DataMapper::Resource
-
-  has n, :checks
-
-  property :id,      Serial
-  property :command, Text, :nullable => false
-  property :name,    String, :nullable => false
-  property :params,  Yaml
-
-  validates_is_unique :command, :name
-
-  def name_for_select
-    cmd = (self.command.size > 30 ? "#{self.command[0..50]}..." : self.command)
-    "#{self.name} (#{cmd})"
-  end
-
-end

data/lib/flapjack/persistence/data_mapper/models/event.rb

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-
-class Event
-  include DataMapper::Resource
-
-  timestamps :at
-
-  belongs_to :check
-
-  property :id, Serial, :key => true
-  property :check_id, Integer, :nullable => false
-  #property :check_output, Text, :nullable => false
-
-  # dm-timestamps
-  property :created_at, DateTime
-  property :updated_at, DateTime
-  property :deleted_at, ParanoidDateTime
-
-end

data/lib/flapjack/persistence/data_mapper/models/node.rb

@@ -1,18 +0,0 @@
-#!/usr/bin/env ruby
-
-class Node
-  include DataMapper::Resource
-
-  has n, :checks
-
-  property :fqdn, String, :key => true
-
-  validates_is_unique :fqdn
-  validates_format :fqdn, :with => /^[0-9|a-z|A-Z|\-|\.]*$/,
-                          :message => "not a RFC1035-formatted FQDN (see section 2.3.1)"
-
-  def hostname
-    self.fqdn.split('.').first
-  end
-
-end

data/lib/flapjack/persistence/data_mapper/models/related_check.rb

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-
-class RelatedCheck
-  include DataMapper::Resource
-
-  belongs_to :parent_check, :class_name => "Check", :child_key => [:parent_id]
-  belongs_to :child_check, :class_name => "Check", :child_key => [:child_id]
-
-  property :id,        Serial, :key => true
-  #property :parent_check_id, Integer, :nullable => false
-  #property :child_check_id,  Integer, :nullable => false
-
-
-
-end

data/lib/flapjack/persistence/sqlite3.rb

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby 
-
-require File.join(File.dirname(__FILE__), 'sqlite3', 'sqlite3')

data/lib/flapjack/persistence/sqlite3/sqlite3.rb

@@ -1,166 +0,0 @@
-#!/usr/bin/env ruby 
-
-require 'sqlite3'
-
-module Flapjack
-  module Persistence
-    class Sqlite3
-      def initialize(options={})
-        @options = options
-        @config = OpenStruct.new(options)
-        @log = @config.log
-        connect
-      end
-
-      def any_parents_failed?(check_id)
-        rows = @db.execute(%(SELECT count(*) FROM "checks" INNER JOIN "related_checks" ON "related_checks".parent_id = "checks".id AND "related_checks".child_id = #{check_id};))
-        rows.flatten.first != "0"
-      end
-
-      def save_check(result)
-        if check = get_check(result[:id])
-          result[:updated_at] = Time.now
-          updates = result.map { |key, value| "#{key} = '#{value}'" }.join(', ')
-          statement = %(UPDATE "checks" SET #{updates} WHERE "id" = #{result[:id]};)
-          @db.execute(statement)
-        else
-          result[:created_at] = Time.now
-          columns, values = columns_and_values_for(result)
-          @db.execute(%(INSERT INTO "checks" #{columns} VALUES #{values}))
-        end
-        result
-      end
-
-      def get_check(id)
-        result = @db.execute2(%(SELECT * FROM "checks" WHERE id = "#{id}"))
-        return nil unless result[1]
-        hash = {}
-        result[0].each_with_index do |key, index|
-          hash[key] = result[1][index]
-        end
-        hash
-      end
-
-      def delete_check(id)
-        result = @db.execute2(%(DELETE FROM "checks" WHERE id = "#{id}"))
-      end
-
-      def all_checks
-        results = @db.execute2(%(SELECT * FROM "checks";))
-        
-        records = results[1..-1].map do |values|
-          hash = {}
-          values.each_with_index do |value, index|
-            hash[results[0][index]] = value
-          end
-          hash
-        end
-        
-        records
-      end
-
-      def save_check_relationship(attrs)
-        columns, values = columns_and_values_for(attrs)
-        @db.execute(%(INSERT INTO "related_checks" #{columns} VALUES #{values}))
-      end
-
-      def all_check_relationships
-        results = @db.execute2(%(SELECT * FROM "related_checks";))
-        
-        records = results[1..-1].map do |values|
-          hash = {}
-          values.each_with_index do |value, index|
-            hash[results[0][index]] = value
-          end
-          hash
-        end
-
-        records
-      end
-
-      # events
-      def all_events_for(id)
-        results = @db.execute2(%(SELECT * FROM "events" WHERE check_id = #{id}))
-
-        records = results[1..-1].map do |values|
-          hash = {}
-          values.each_with_index do |value, index|
-            hash[results[0][index]] = value
-          end
-          hash
-        end
-
-        records
-      end
-
-      def all_events
-        results = @db.execute2(%(SELECT * FROM "events";))
-
-        records = results[1..-1].map do |values|
-          hash = {}
-          values.each_with_index do |value, index|
-            hash[results[0][index]] = value
-          end
-          hash
-        end
-
-        records
-      end
-
-      def create_event(result)
-        @db.execute(%(INSERT INTO "events" ("check_id", "created_at") VALUES ("#{result.result.check_id}", "#{Time.now}")))
-        true
-      end
-
-      private
-      def connect
-        raise ArgumentError, "Database location wasn't specified" unless @config.database
-        @db = ::SQLite3::Database.new(@config.database)
-
-        auto_migrate if @config.auto_migrate
-      end
-
-      def auto_migrate
-        statements = [
-					%(DROP TABLE IF EXISTS "check_templates"),
-					%(DROP TABLE IF EXISTS "events"),
-					%(DROP TABLE IF EXISTS "related_checks"),
-					%(DROP TABLE IF EXISTS "checks"),
-					%(DROP TABLE IF EXISTS "nodes"),
-					%(PRAGMA table_info('nodes')),
-					%(SELECT sqlite_version(*)),
-					%(CREATE TABLE "nodes" ("fqdn" VARCHAR(50) NOT NULL, PRIMARY KEY("fqdn"))),
-					%(PRAGMA table_info('checks')),
-					%(CREATE TABLE "checks" ("created_at" DATETIME, "updated_at" DATETIME, "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, "command" TEXT NOT NULL, "params" TEXT DEFAULT NULL, "name" VARCHAR(50) NOT NULL, "enabled" BOOLEAN DEFAULT 'f', "status" INTEGER DEFAULT 0, "deleted_at" DATETIME DEFAULT NULL, "node_fqdn" VARCHAR(50), "check_template_id" INTEGER)),
-					%(PRAGMA table_info('related_checks')),
-					%(CREATE TABLE "related_checks" ("parent_id" INTEGER, "child_id" INTEGER, "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT)),
-					%(PRAGMA table_info('events')),
-					%(CREATE TABLE "events" ("created_at" DATETIME, "updated_at" DATETIME, "check_id" INTEGER NOT NULL, "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, "deleted_at" DATETIME DEFAULT NULL)),
-					%(PRAGMA table_info('check_templates')),
-					%(CREATE TABLE "check_templates" ("id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, "command" TEXT NOT NULL, "name" VARCHAR(50) NOT NULL, "params" TEXT DEFAULT NULL))
-        ]
-
-        statements.each do |statement|
-          @db.execute(statement)
-        end
-      end
-
-      def columns_and_values_for(result)
-        @keys = []
-        @values = []
-        
-        result.each_pair do |k,v|
-          @keys << k
-          @values << v
-        end
-
-        keys   = "(\"" + @keys.join(%(", ")) + "\")"
-        values = "(\"" + @values.join(%(", ")) + "\")"
-
-        return keys, values
-      end
-
-    end
-  end
-end
-

data/lib/flapjack/transports/beanstalkd.rb

@@ -1,50 +0,0 @@
-#!/usr/bin/env ruby
-
-$: << File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
-require 'beanstalk-client'
-require 'flapjack/transports/result'
-
-module Flapjack
-  module Transport
-    class Beanstalkd
-      def initialize(options={})
-        @options = options
-        @config = OpenStruct.new(options)
-        @log    = @config.log
-
-        unless @config.host && @config.port && @config.queue_name
-          raise ArgumentError, "You need to specify a beanstalkd host, port, and queue name to connect to."
-        end
-
-        connect
-      end
-
-      def connect
-        begin
-          @queue = Beanstalk::Pool.new(["#{@config.host}:#{@config.port}"], @config.queue_name)
-        rescue Beanstalk::NotConnected => e
-          @log.error("Couldn't connect to the '#{@config.queue_name}' Beanstalk queue. Retrying in 5 seconds.")
-          sleep 5
-          retry
-        end
-      end
-
-      def next
-        begin
-          job = @queue.reserve # blocks
-          result = YAML::load(job.body)
-          Flapjack::Transport::Result.new(:job => job, :result => result)
-        rescue Beanstalk::NotConnected
-          @log.error("The '#{@config.queue_name}' Beanstalk queue went away. Waiting 5 seconds, then retrying.")
-          sleep 5
-          retry
-        end
-      end
-
-      def delete(result)
-        result.job.delete
-      end
-    end
-  end
-end
-

data/lib/flapjack/transports/result.rb

@@ -1,58 +0,0 @@
-#!/usr/bin/env ruby
-
-module Flapjack
-  module Transport
-    class Result
-
-      attr_accessor :job, :result
-
-      def initialize(options={})
-        @job = options[:job]
-        @result = OpenStruct.new(options[:result])
-      end
-
-      # Whether a check returns an ok status.
-      def ok?
-        @result.retval == 0
-      end
-
-      # Whether a check has a warning status.
-      def warning?
-        @result.retval == 1
-      end
-
-      # Whether a check has a critical status.
-      def critical?
-        @result.retval == 2
-      end
-
-      # Human readable representation of the check's return value.
-      def status
-        case @result.retval
-        when 0 ; "ok"
-        when 1 ; "warning"
-        when 2 ; "critical"
-        end
-      end
-
-      # FIXME: there is a *lot* of duplication here - implement a proxy
-      # object pattern?
-      def id
-        @result.check_id
-      end
-
-      def check_id
-        @result.check_id
-      end
-
-      def command
-        @result.command
-      end
-
-      def frequency
-        @result.frequency
-      end
-
-    end
-  end
-end

data/lib/flapjack/worker/application.rb

@@ -1,121 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'log4r'
-require 'log4r/outputter/syslogoutputter'
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'patches'))
-
-module Flapjack
-  module Worker
-    class Application
-
-      # boots the worker
-      def self.run(options={})
-        app = self.new(options)
-        app.setup_loggers
-        app.setup_config
-        app.setup_queues
-
-        app
-      end
-
-      attr_accessor :log
-
-      def initialize(options={})
-        @log = options[:log]
-        @options = options
-
-        setup_event_handlers
-      end
-
-
-      def setup_event_handlers
-        at_exit do
-          @log.info("Shutting down")
-        end
-
-        trap("INT") do
-          puts "Caught shutdown signal, cleaning up."
-          exit
-        end
-      end
-
-      def setup_loggers
-        unless @log
-          @log = Log4r::Logger.new("worker")
-          @log.add(Log4r::StdoutOutputter.new("worker"))
-          @log.add(Log4r::SyslogOutputter.new("worker"))
-        end
-      end
-
-      def setup_config
-        @config = OpenStruct.new(@options)
-      end
-
-      def setup_queues
-        defaults = { :backend => :beanstalkd,
-                     :host => 'localhost',
-                     :port => '11300',
-                     :log => @log }
-        config = defaults.merge(@config.transport || {})
-        basedir = config.delete(:basedir) || File.join(File.dirname(__FILE__), '..', 'transports')
-
-        %w(results checks).each do |queue_name|
-
-          queue_config = config.merge(:queue_name => queue_name)
-
-          class_name = config[:backend].to_s.camel_case
-          filename = File.expand_path(File.join(basedir, "#{config[:backend]}.rb"))
-
-          @log.info("Loading the #{class_name} transport for queue: #{queue_name}.")
-
-          begin
-            require filename
-            transport = Flapjack::Transport.const_get("#{class_name}")
-            queue     = transport.new(queue_config)
-            instance_variable_set("@#{queue_name}_queue", queue)
-          rescue LoadError => e
-            @log.warning("Attempted to load #{class_name} transport, but it doesn't exist!")
-            @log.warning("Exiting.")
-            raise # preserves original exception
-          end
-        end
-      end
-
-      def log(level, opts={})
-        if opts[:data]
-          @log.method(level).call(pp opts[:data])
-        else
-          @log.method(level).call(opts[:message])
-        end
-      end
-
-      def process_check
-        @log.info("Waiting for check...")
-        check = @checks_queue.next
-        @log.info("Processing check with id #{check.check_id}")
-
-        command = "sh -c '#{check.command}'"
-        @log.info("Executing check: #{command}")
-
-        output = `#{command}`
-        return_value = $?.exitstatus
-
-        @log.info("Sending result.")
-        @results_queue.put({:check_id => check.check_id, :output => output, :retval => return_value})
-        @log.info("Returning check to transport.")
-        @checks_queue.put({:check_id => check.check_id, :command => check.command, :frequency => check.frequency})
-
-        @log.info("Cleaning up check.")
-        @checks_queue.delete(check)
-      end
-
-      def main
-        @log.info("Booting main loop.")
-        loop do
-          process_check
-        end
-      end
-
-    end
-  end
-end