fluke 0.0.5

data/README.rdoc

@@ -0,0 +1,47 @@
+= fluke
+
+* http://github.com/maxaf/fluke
+
+== DESCRIPTION:
+
+A simple resource observer designed to detect change over time.
+
+== SYNOPSIS:
+
+  $ fluke --help
+
+== REQUIREMENTS:
+
+* Ruby 1.8.6+ || JRuby 1.3.1+
+* DataMapper 0.10.0+
+* Some database
+* github.com/marcel/aws-s3
+
+== INSTALL:
+
+  # gem install fluke
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Max Afonov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/fluke

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require File.expand_path(File.dirname(__FILE__) + "/../lib/fluke")
+require "fluke/cli"
+
+Fluke::CLI.execute(STDOUT, STDERR, ARGV)

data/lib/fluke.rb

@@ -0,0 +1,97 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'yaml'
+require 'fluke/watcher'
+require 'fluke/monkey_patch'
+require 'aws/s3'
+require 'thread'
+require 'dm-core'
+
+module Fluke
+  VERSION = '0.0.4'
+  ROOT = Dir.new(File.expand_path(File.dirname(__FILE__) + "/../"))
+  DEFAULT_CONF_PATH = "~/.fluke.yml"
+  @@verbose = false
+  @@watchers = {}
+  @@mutex = { :s3 => Mutex.new }
+
+  def self.verbose?
+    @@verbose
+  end
+
+  def self.verbose=(v = false)
+    @@verbose = v ? true : false
+  end
+
+  def self.watchers
+    @@watchers
+  end
+
+  def self.conf
+    @@conf.dup
+  end
+
+  def self.mutex
+    @@mutex
+  end
+
+  def self.log
+    return unless verbose? and block_given?
+    @@log_here.puts yield
+  end
+
+  def self.watch(watcher, &init)
+    unless watcher.is_a?(Watcher)
+      watcher = Watcher.first(:name => watcher.to_s)
+    end
+    watchers[watcher.name] = watcher
+    if init
+      watcher.instance_eval &init
+    end
+  end
+
+  def self.configure!(opts = {})
+    p = {
+      :conf_path => File.expand_path(DEFAULT_CONF_PATH),
+      :stdout => STDOUT,
+      :stderr => STDERR,
+      :log_here => :stderr
+    }
+    p.merge! opts
+    @@log_here = p[p[:log_here]] || p[:stderr]
+
+    begin
+      @@conf = YAML::load(File.open(p[:conf_path]))
+      if !@@conf[:proxy].nil?
+        @@conf[:s3][:connection][:proxy] = @@conf[:proxy]
+        @@conf[:proxy_string] = "http://#{@@conf[:proxy][:host]}:#{@@conf[:proxy][:port]}"
+      end
+      if verbose?
+        DataMapper::Logger.new(@@log_here, :debug)
+      end
+      DataMapper.setup(:default, @@conf[:db])
+      AWS::S3::Base.establish_connection!(@@conf[:s3][:connection])
+      Result::Body.set_current_bucket_to @@conf[:s3][:bucket][:result]
+    rescue => e
+      STDERR.puts e.inspect
+      return false
+    end
+    return true
+  end
+
+  def self.run!
+    watchers.each do |n,watcher|
+      watcher.thread = Thread.new do
+        while true
+          watcher.run
+          watcher.wait
+        end
+      end
+    end
+
+    sleep while true
+  end
+
+end

data/lib/fluke/cli.rb

@@ -0,0 +1,56 @@
+require 'optparse'
+
+module Fluke
+  class CLI
+    def self.execute(stdout, stderr, arguments=[])
+      p = {
+        :stdout => stdout, :stderr => stderr
+      }
+
+      parser = OptionParser.new do |opts|
+        opts.banner = <<-BANNER.gsub(/^          /,'')
+          A simple resource observer designed to detect change over time.
+
+          Usage: #{File.basename($0)} [options]
+                 # run all watchers
+
+                 -OR-
+
+                 #{File.basename($0)} [options] arg1..argN
+                 # args are either files, in which case watcher info is
+                 # inferred based on file content, or watcher names
+          Options are:
+        BANNER
+        opts.separator ""
+        opts.on("-c", "--conf", String,
+                "Config file location",
+                "Default: #{Fluke::DEFAULT_CONF_PATH}") { |arg| p[:conf_path] = arg || nil }
+        opts.on("-v", "--verbose",
+                "Be chatty.",
+                "Default: false") { |arg| Fluke.verbose = arg }
+        opts.on("-h", "--help",
+                "Show this help message.") { stderr.puts opts; exit }
+        opts.parse!(arguments)
+      end
+
+      Fluke.configure! p
+
+      if arguments.size > 0 then
+        arguments.uniq.each do |name|
+          if File.exists?(name) and !File.directory?(name) then
+            path = File.expand_path(name)
+            Fluke.class_eval(File.read(path), path)
+          else
+            Fluke.watch name
+          end
+        end
+      else
+        Watcher.all.each do |watcher|
+          Fluke.watch watcher
+        end
+      end
+
+      Fluke.run!
+    end
+  end
+end

data/lib/fluke/monkey_patch.rb

@@ -0,0 +1,35 @@
+module Fluke
+  module Delays
+    def seconds
+      self*1000
+    end
+
+    def minutes
+      self.seconds*60
+    end
+
+    def hours
+      self.minutes*60
+    end
+
+    def days
+      self.hours*24
+    end
+
+    def weeks
+      self.days*7
+    end
+
+    def months
+      self.weeks*4
+    end
+  end
+end
+
+class Fixnum
+  include Fluke::Delays
+end
+
+class Float
+  include Fluke::Delays
+end

data/lib/fluke/result.rb

@@ -0,0 +1,67 @@
+require 'digest/sha1'
+require 'aws/s3'
+require 'differ'
+
+module Fluke
+  class Result
+    include DataMapper::Resource
+    storage_names[:default] = 'results'
+    property :id, Serial, :key => true
+    property :checksum, String
+    property :url, String
+    property :created_at, DateTime
+    property :updated_at, DateTime
+    belongs_to :watcher
+
+    class Body < AWS::S3::S3Object
+    end
+
+    def body_key
+      "#{self.watcher.name}/#{self.checksum}"
+    end
+
+    def body
+      begin
+        return Fluke.mutex[:s3].synchronize do
+          Body.find self.body_key
+        end
+      rescue AWS::S3::NoSuchKey => nsk
+        return nil
+      end
+    end
+
+    def body?
+      Fluke.mutex[:s3].synchronize { Body.exists? self.body_key }
+    end
+
+    def self.from_response(args)
+      opts = {
+        :mime_type => 'binary/octet-stream',
+        :generated_url => nil
+      }.merge(args)
+
+      checksum = Digest::SHA1.hexdigest(opts[:content])
+      result = Result.new :checksum => checksum
+      result.watcher = opts[:watcher]
+      if opts[:generated_url] and opts[:generated_url] != opts[:watcher].url
+        result.url = opts[:generated_url]
+      end
+      result.save
+
+      if result.body?
+        Fluke.log { "#{result.watcher} exists: #{result.body_key}" }
+      else
+        Fluke.log { "#{result.watcher} store: #{result.body_key}" }
+        Fluke.mutex[:s3].synchronize do
+          Body.store(result.body_key, opts[:content].dup, :content_type => opts[:mime_type])
+        end
+      end
+
+      result
+    end
+
+    def diff_against(right)
+      differ = Differ.diff_by_line(self.body.value, right.body.value)
+    end
+  end
+end

data/lib/fluke/watcher.rb

@@ -0,0 +1,111 @@
+require 'rubygems'
+require 'dm-core'
+require 'fluke/result'
+require 'httpclient'
+
+module Fluke
+  class Watcher
+    include DataMapper::Resource
+    storage_names[:default] = 'watchers'
+    property :id, Serial, :key => true
+    property :name, String
+    property :url, String
+    property :delay, Float
+    property :meth, String
+    property :created_at, DateTime
+    property :updated_at, DateTime
+    has n, :results
+
+    attr_accessor :thread
+
+    def run
+      Thread.new do
+        begin
+          generated_url = self.generate_url
+          Fluke::log { "#{self}: generated URL: #{generated_url}" }
+
+          Thread.current[:result] = \
+          if generated_url =~ /^file\:\/\/(.+)$/
+            run_file File.expand_path($1)
+          else
+            run_http generated_url
+          end
+        rescue => e
+          Fluke.log { "#{self}: failed to run: #{e.inspect}; backtrace: #{e.backtrace.join("; ")}" }
+        end
+      end
+    end
+
+    def run_file(path)
+      result = Result.from_response \
+      :watcher => self, :content => extract_content(File.read(path)), :generated_url => "file://#{path}"
+    end
+
+    def run_http(generated_url)
+      hc = HTTPClient.new :proxy => Fluke.conf[:proxy_string], :user_agent => "Fluke/#{Fluke::VERSION}"
+      http_method = self.meth.downcase.to_sym
+      unless hc.respond_to?(http_method)
+        Fluke::log { "#{self}: invalid method '#{http_method}', converting to :get" }
+        http_method = :get
+      end
+      res = hc.send(http_method, generated_url, { 'Cache-Control' => 'no-cache', 'Pragma' => 'no-cache' })
+      result = Result.from_response \
+      :watcher => self, :content => extract_content(res.body.dump.dup),
+      :generated_url => generated_url, :mime_type => res.header['Content-Type']
+    end
+
+    def url_generator(&block)
+      @generate_url = true
+      @url_generator = block
+    end
+
+    def url_strftime(offset = 0)
+      self.url_generator do |raw|
+        (Time.now + offset/1000.000).strftime(raw)
+      end
+    end
+
+    def generate_url
+      if @generate_url
+        if @url_generator.arity then
+          return @url_generator.call(self.url)
+        else
+          return @url_generator.call
+        end
+      else
+        return self.url
+      end
+    end
+
+    def content_extractor(&block)
+      @extract_content = true
+      @content_extractor = block
+    end
+
+    def extract_content(content)
+      if @extract_content
+        return @content_extractor.call(content)
+      else
+        return content
+      end
+    end
+
+    def wait
+      dur = self.delay/1000.000
+      Fluke::log { "#{self}: sleeping #{dur} seconds" }
+      sleep dur
+    end
+
+    def to_s
+      "Watcher<#{name}>"
+    end
+
+    def last_result(checksum = nil)
+      if checksum
+        results.last(:checksum => checksum, :order => [ :created_at.desc ])
+      else
+        results.last(:order => [ :created_at.desc ])
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: fluke
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: ruby
+authors: 
+  - Max Afonov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-16 00:00:00 -05:00
+default_executable: fluke
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: aws-s3
+    type: :runtime
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 0.6.2
+      version: 
+  - !ruby/object:Gem::Dependency 
+    name: httpclient
+    type: :runtime
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 2.1.5.2
+      version: 
+  - !ruby/object:Gem::Dependency 
+    name: differ
+    type: :runtime
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 0.1.1
+      version: 
+  - !ruby/object:Gem::Dependency 
+    name: dm-core
+    type: :runtime
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 0.10.0
+      version: 
+description: Watch resources and determine how they change over time. Useful for post-mortem investigations.
+email: max@bumnetworks.com
+executables: 
+  - fluke
+extensions: []
+
+extra_rdoc_files: 
+  - README.rdoc
+files: 
+  - lib/fluke.rb
+  - lib/fluke/cli.rb
+  - lib/fluke/monkey_patch.rb
+  - lib/fluke/result.rb
+  - lib/fluke/watcher.rb
+  - README.rdoc
+has_rdoc: true
+homepage: http://github.com/maxaf/fluke
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --charset=UTF-8
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Track change over time
+test_files: []
+