fog_tracker 0.1.0

data/.gitignore

@@ -0,0 +1,13 @@
+*.gem
+.bundle
+Gemfile.lock
+config/accounts.yml
+pkg/*
+*~
+.DS_Store
+*.tmproj
+db/*.sqlite3
+log/*.log
+tmp/**/*
+doc
+doc/**/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in fog_tracker.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,6 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rake', :task => 'spec' do
+  watch(%r{^*.rb})
+end

data/README.md

@@ -0,0 +1,90 @@
+Fog Tracker
+================
+Uses the Fog gem to track the state of cloud computing resources across multiple accounts, with multiple service providers.
+
+  *BETA VERSION - needs functional testing with more cloud computing providers*
+
+
+----------------
+What is it?
+----------------
+The Fog Tracker uses the [Fog gem](https://github.com/fog/fog) to periodically poll one or more cloud computing accounts, and determines the state of their associated cloud computing "Resources": compute instances, disk volumes, stored objects, and so on. The most recent state of all Resources is saved in memory (as Fog objects), and can be accessed repeatedly with no network overhead, using a simple, Regular-Expression-based query.
+
+
+----------------
+Why is it?
+----------------
+The Fog Tracker is intended to be a foundation library, on top of which more complex cloud dashboard or management applications can be built. It allows such applications to decouple their requests to cloud service providers from their access to the results of those requests.
+
+
+----------------
+Where is it? (Installation)
+----------------
+Install the Fog Tracker gem (and its dependencies if necessary) from RubyGems
+
+    gem install fog_tracker [rake bundler]
+
+
+----------------
+How is it [done]? (Usage)
+----------------
+1) Just require the gem, and create a `FogTracker::Tracker`. Pass it some account information in a hash, perhaps loaded from a YAML file:
+
+    require 'fog_tracker'
+    tracker = FogTracker::Tracker.new(YAML::load(File.read 'accounts.yml'))
+    tracker.start
+
+  Here are the contents of a sample `accounts.yml`:
+
+    AWS EC2 development account:
+      :provider: AWS
+      :service: Compute
+      :credentials:
+        :aws_access_key_id: XXXXXXXXXXXXXXXXXXXX
+        :aws_secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+      :polling_time: 180
+	  :exclude_resources:
+	  - :flavors
+	  - :images
+    Rackspace development account:
+      :provider: Rackspace
+      :service: Compute
+      :credentials:
+        :rackspace_api_key: XXXXXXXXXXXXXXXXXXXX
+        :rackspace_username: XXXXXXXXX
+      :polling_time: 180
+
+2) The tracker will run asynchronously, with one thread per account. You can call `start()` and `stop()` on it, and query the resulting collections of Fog Resource objects using a filter-based query:
+
+	# get all Compute instances across all accounts and providers
+	tracker.query("*::Compute::*::servers")
+
+	# get all Amazon EC2 Resources, of all types, across all accounts
+	tracker["*::Compute::AWS::*"]	# the [] operator is the same as query()
+
+	# get all S3 objects in a given account
+	tracker["my production account::Storage::AWS::files"]
+
+  The query string format is:    "`account name::service::provider::collection`"
+
+  You can also pass a Proc to the Tracker at initialization, which will be invoked whenever an account's Resources have been updated -- see the API docs for details.
+
+
+----------------
+Who is it? (Contribution / Development)
+----------------
+This Gem was created by Benton Roberts _(benton@bentonroberts.com)_ The project is still in its early stages, and needs to be tested with many more of Fog's cloud providers. Helping hands are appreciated!
+
+1) Install project dependencies.
+
+    gem install rake bundler
+
+2) Fetch the project code and bundle up...
+
+    git clone https://github.com/benton/fog_tracker.git
+    cd fog_tracker
+    bundle
+
+3) Run the tests:
+
+    rake

data/Rakefile

@@ -0,0 +1,9 @@
+# Set up bundler
+%w{rubygems bundler bundler/gem_tasks}.each {|dep| require dep}
+Bundler.setup(:default, :test, :development)
+
+# Load all tasks from 'lib/tasks'
+Dir["#{File.dirname(__FILE__)}/lib/tasks/*.rake"].sort.each {|ext| load ext}
+
+desc 'Default: run specs.'
+task :default => :spec

data/bin/tracker

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+# == Synopsis
+#   Uses the Fog gem to track the status of cloud computing resources
+#
+# == Usage
+#   tracker.rb [options] ACCOUNTS_CONFIG_FILE.YML
+#
+# == Options (all options can be put into the config file)
+#   -d, --delay [INTEGER]       Seconds between status updates. default = 180
+#   -l, --log-level [LEVEL]     Sets Log4r level for console output. default = INFO
+#   -h, --help                  Displays help message
+#
+# == Author
+#   Benton Roberts
+
+require 'optparse'
+require 'fog_tracker'
+LOG_LVLS = {
+  "DEBUG" => ::Logger::DEBUG,
+  "INFO"  => ::Logger::INFO,
+  "WARN"  => ::Logger::WARN,
+  "ERROR" => ::Logger::ERROR,
+  "FATAL" => ::Logger::FATAL
+}
+
+module FogTracker
+  class FogTrackerConsoleApp
+
+    def initialize
+      @log = FogTracker.default_logger(STDOUT)
+      parse_options
+      @log.info "Loading account information from #{ARGV[0]}"
+      @accounts = YAML::load(File.open(ARGV[0]))
+      @tracker = FogTracker::Tracker.new(
+        @accounts, {:logger => @log, :delay => @opts[:delay]}
+      )
+    end
+
+    def go
+      @tracker.start
+      while true do
+        sleep 60   # Loop forever
+      end
+    end
+
+    def parse_options
+      @opts = {:log_level  => 'INFO'}
+      optparse = OptionParser.new do |opts|
+        opts.banner = "Usage: tracker [options] ACCOUNTS.YML"
+        opts.on('-d', '--delay SECONDS', Integer,
+        'Number of seconds between status updates') do |delay|
+          @opts[:delay] = delay
+        end
+        opts.on('-l', '--log-level LEVEL', 'Set logging level') do |log_level|
+          @opts[:log_level] = log_level.upcase
+        end
+        opts.on('-h', '--help', 'Display this help message') do
+          puts opts ; exit
+        end
+      end
+      optparse.parse!
+      @log.level = LOG_LVLS[@opts[:log_level]] if LOG_LVLS[@opts[:log_level]]
+      if ARGV.count < 1
+        @log.error "A YAML file with account info must be specified"
+        exit 1
+      end
+    end
+
+  end
+end
+
+FogTracker::FogTrackerConsoleApp.new.go

data/config/accounts.yml.example

@@ -0,0 +1,25 @@
+AWS EC2 production account: 
+  :provider: AWS
+  :service: Compute
+  :credentials: 
+    :aws_access_key_id: XXXXXXXXXXXXXXXXXXXX
+    :aws_secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+  :polling_time: 120
+  :exclude_resources:
+AWS EC2 development account: 
+  :provider: AWS
+  :service: Compute
+  :credentials: 
+    :aws_access_key_id: XXXXXXXXXXXXXXXXXXXX
+    :aws_secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+  :polling_time: 180
+  :exclude_resources:
+  - :flavors
+  - :images
+Rackspace development account: 
+  :provider: Rackspace
+  :service: Compute
+  :credentials: 
+    :rackspace_api_key: XXXXXXXXXXXXXXXXXXXX
+    :rackspace_username: XXXXXXXXX
+  :polling_time: 180

data/fog_tracker.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fog_tracker/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fog_tracker"
+  s.version     = FogTracker::VERSION
+  s.authors     = ["Benton Roberts"]
+  s.email       = ["benton@bentonroberts.com"]
+  s.homepage    = "http://github.com/benton/fog_tracker"
+  s.summary     = %q{Tracks the state of cloud computing resources across }+
+                  %q{multiple accounts with multiple service providers}
+  s.description = %q{This gem peridically polls mutiple cloud computing }+
+                  %q{services using the fog gem, asynchronously updating the }+
+                  %q{state of the resulting collections of Fog Resources.}
+
+  s.rubyforge_project = "fog_tracker"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # Runtime dependencies
+  s.add_dependency "fog"
+
+  # Development / Test dependencies
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rdoc"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-rake"
+  s.add_development_dependency "ruby_gntp"
+end

data/lib/fog_tracker.rb

@@ -0,0 +1,23 @@
+require 'logger'
+
+# Load all ruby files from 'fog_tracker' directory
+Dir[File.join(File.dirname(__FILE__), "fog_tracker/**/*.rb")].each {|f| require f}
+
+module FogTracker
+
+  # The default polling interval in seconds
+  # This. can be overriden when a FogTracker::Tracker is created, either
+  # in the +accounts+ definitions, or in the +options+ parameter
+  DEFAULT_POLLING_TIME = 300   # by default, poll all accounts every 5 minutes
+
+  # Returns a slightly-modified version of the default Ruby Logger
+  def self.default_logger(output = nil)
+    logger = ::Logger.new(output)
+    logger.sev_threshold = Logger::INFO
+    logger.formatter = proc {|lvl, time, prog, msg|
+      "#{lvl} #{time.strftime '%Y-%m-%d %H:%M:%S %Z'}: #{msg}\n"
+    }
+    logger
+  end
+
+end

data/lib/fog_tracker/account_tracker.rb

@@ -0,0 +1,96 @@
+module FogTracker
+
+  # Tracks a single Fog account in an ActiveRecord database
+  class AccountTracker
+    require 'fog'
+
+    attr_reader :name, :account, :log, :delay
+    attr_reader :resource_trackers
+
+    # Creates an object for tracking a single Fog account
+    #
+    # ==== Attributes
+    #
+    # * +account_name+ - a human-readable name for the account (String)
+    # * +account+ - a Hash of account information (see accounts.yml.example)
+    # * +options+ - Hash of optional parameters
+    #
+    # ==== Options
+    #
+    # * +:delay+ - Default time between polling of accounts
+    # * +:callback+ - A Method or Proc to call each time an account is polled.
+    #     It should take the name of the account as its only required parameter
+    # * +:logger+ - a Ruby Logger-compatible object
+    def initialize(account_name, account, options={})
+      @name     = account_name
+      @account  = account
+      @callback = options[:callback]
+      @log      = options[:logger] || FogTracker.default_logger
+      @delay    = options[:delay]  || account[:polling_time] ||
+                              FogTracker::DEFAULT_POLLING_TIME
+      @log.debug "Creating tracker for account #{@name}."
+      create_resource_trackers
+    end
+
+    # Starts a background thread, which updates all @resource_trackers
+    def start
+      if not running?
+      @log.debug "Starting tracking for account #{@name}..."
+        @timer = Thread.new do
+          begin
+            while true do
+              @log.info "Polling account #{@name}..."
+              @resource_trackers.each {|tracker| tracker.update}
+              @callback.call @name if @callback
+              sleep @delay
+            end
+          rescue Exception => e
+            @log.error "Exception polling account #{name}: #{e.message}"
+            @log.error e.backtrace.join("\n")
+            exit 99
+          end
+        end
+      else
+        @log.info "Already tracking account #{@name}"
+      end
+    end
+
+    # Stops all the @resource_trackers
+    def stop
+      if running?
+        @log.info "Stopping tracker for #{name}..."
+        @timer.kill
+        @timer = nil
+      else
+        @log.info "Tracking already stopped for account #{@name}"
+      end
+    end
+
+    # Returns true or false depending on whether this tracker is polling
+    def running? ; @timer != nil end
+
+    # Returns a Fog::Connection object to this account's Fog service
+    def connection
+      service_mod = ::Fog::const_get @account[:service]
+      provider_class = service_mod.send(:const_get, @account[:provider])
+      @fog_service ||= provider_class.new(@account[:credentials])
+    end
+
+    # Returns an Array of resource types (Strings) to track
+    def tracked_types
+      types = connection.collections - (account[:exclude_resources] || [])
+      types.map {|type| type.to_s}
+    end
+
+    private
+
+    # Creates and returns an Array of ResourceTracker objects -
+    # one for each resource type associated with this account's service
+    def create_resource_trackers
+      @resource_trackers = tracked_types.map do |fog_collection_name|
+        FogTracker::ResourceTracker.new(fog_collection_name.to_s, self)
+      end
+    end
+
+  end
+end

data/lib/fog_tracker/query/query_processor.rb

@@ -0,0 +1,95 @@
+module FogTracker
+  module Query
+    class QueryProcessor
+
+      QUERY_PATTERN = %r{(.*)::(.*)::(.*)::(.*)}
+
+      # Creates an object for filtering Resources from a set of AccountTrackers
+      #
+      # ==== Attributes
+      #
+      # * +trackers+ - a Hash of AccountTrackers, indexed by Account name
+      # * +options+ - Hash of optional parameters
+      #
+      # ==== Options
+      #
+      # * +:logger+ - a Ruby Logger-compatible object
+      def initialize(trackers, options={})
+        @trackers = trackers
+        @log      = options[:logger] || FogTracker.default_logger
+      end
+
+      # Returns an Array of Resources, filtered by +query+
+      def execute(query)
+        acct_pattern, svc_pattern, prov_pattern, col_pattern = parse_query(query)
+        results_by_account = get_results_by_account(acct_pattern)
+        results = filter_by_service(results_by_account, svc_pattern)
+        results = filter_by_provider(results, prov_pattern)
+        results = filter_by_collection(results, col_pattern)
+      end
+
+      private
+
+      # Returns an Array of 4 RegEx objeccts based on the +query_string+
+      # for matching [account name, service, provider, collection]
+      def parse_query(query_string)
+        @log.debug "Parsing Query #{query_string}"
+        tokenize(query_string).map {|token| regex_from_token(token)}
+      end
+
+      # Returns an array of 4 String tokens by splitting +query_string+
+      def tokenize(query_string)
+        query_string.strip!
+        if match = query_string.match(QUERY_PATTERN)
+          match.captures
+        else
+          raise "Bad query: '#{query_string}'"
+        end
+      end
+
+      # Converts a String +token+ into a RegEx for matching query values
+      def regex_from_token(token)
+        token = '.*' if token == '*'  # a single wildcard is a special case
+        %r{^\s*#{token}\s*$}i         # otherwise, interpret as a RegEx
+      end
+
+      # Returns a subset of all Resources, filtered only by +acct_name_pattern+
+      def get_results_by_account(acct_name_pattern)
+        results = Array.new
+        @trackers.each do |account_name, account_tracker|
+          if account_name.match acct_name_pattern
+            account_tracker.resource_trackers.each do |resource_tracker|
+              results += resource_tracker.collection
+            end
+          end
+        end
+        results
+      end
+
+      # filters an Array of Fog Resources by Service
+      def filter_by_service(resources, service_pattern)
+        resources.select do |resource|
+          service_name = resource.class.name.match(/Fog::(\w+)::/)[1]
+          service_name.match service_pattern
+        end
+      end
+
+      # filters an Array of Fog Resources by Provider
+      def filter_by_provider(resources, provider_pattern)
+        resources.select do |resource|
+          provider_name = resource.class.name.match(/Fog::\w+::(\w+)::/)[1]
+          provider_name.match provider_pattern
+        end
+      end
+
+      # filters an Array of Fog Resources by collection name (Resource Type)
+      def filter_by_collection(resources, collection_pattern)
+        resources.select do |resource|
+          collection_class = resource.collection.class.name.match(/::(\w+)$/)[1]
+          collection_class.to_underscore.match collection_pattern
+        end
+      end
+
+    end
+  end
+end

data/lib/fog_tracker/resource_tracker.rb

@@ -0,0 +1,33 @@
+module FogTracker
+
+  # Tracks a single Fog Resource type for a single Account
+  class ResourceTracker
+
+    attr_accessor :collection
+
+    # Creates an object for tracking a single Fog account
+    #
+    # ==== Attributes
+    #
+    # * +resource_type+ - the Fog collection name (String) for this resource type
+    # * +account_tracker+ - the AccountTracker for this tracker's @collection
+    def initialize(resource_type, account_tracker)
+      @type             = resource_type
+      @account_tracker  = account_tracker
+      @account          = account_tracker.account
+      @account_name     = account_tracker.name
+      @log              = account_tracker.log
+      @collection       = Array.new
+      @log.debug "Created tracker for #{@type} on #{@account_name}."
+    end
+
+    # Polls the account's connection for updated info on all existing
+    # instances of the relevant resource type, and saves them as @collection
+    def update
+      @log.info "Polling #{@type} on #{@account_name}..."
+      @collection = @account_tracker.connection.send(@type)
+      @log.info "Discovered #{@collection.count} #{@type} on #{@account_name}."
+    end
+
+  end
+end

data/lib/fog_tracker/tracker.rb

@@ -0,0 +1,91 @@
+module FogTracker
+
+  # Tracks one or more Fog accounts and exposes a query() on the results
+  class Tracker
+
+    attr_accessor :accounts
+
+    # Creates an object for tracking Fog accounts
+    #
+    # ==== Attributes
+    #
+    # * +accounts+ - a Hash of account information (see accounts.yml.example)
+    # * +options+ - Hash of optional parameters
+    #
+    # ==== Options
+    #
+    # * +:delay+ - Time between polling of accounts. Overrides per-account value
+    # * +:callback+ - A Proc to call each time an account is polled.
+    #     It should take the name of the account as its only required parameter
+    # * +:logger+ - a Ruby Logger-compatible object
+    def initialize(accounts = {}, options = {})
+      @accounts = accounts
+      @delay    = options[:delay]
+      @callback = options[:callback]
+      @log      = options[:logger] || FogTracker.default_logger
+      # Create a Hash that maps account names to AccountTrackers
+      create_trackers
+    end
+
+    # Invokes the start method on all the @trackers
+    def start
+      if not running?
+        @log.info "Tracking #{@trackers.keys.count} accounts..."
+        @trackers.each_value {|tracker| tracker.start}
+        @running = true
+      else
+        @log.info "Already tracking #{@trackers.keys.count} accounts"
+      end
+    end
+
+    # Invokes the stop method on all the @trackers
+    def stop
+      if running?
+        @log.info "Stopping tracker..."
+        @trackers.each_value {|tracker| tracker.stop}
+        @running = false
+      else
+        @log.info "Tracking already stopped"
+      end
+    end
+
+    # Returns true or false/nil depending on whether this tracker is polling
+    def running? ; @running end
+
+    # Returns an array of Resource types (Strings) for a given account
+    def types_for_account(account_name)
+      @trackers[account_name].tracked_types
+    end
+
+    # Returns an array of Resources matching the +query_string+
+    #
+    # ==== Attributes
+    #
+    # * +query_string+ - a String used to filter the discovered Resources
+    #          it might look like: "Account Name::Compute::AWS::servers"
+    def query(query_string)
+      FogTracker::Query::QueryProcessor.new(
+        @trackers, :logger => @log
+      ).execute(query_string)
+    end
+    alias :[] :query
+
+    # Returns this tracker's logger, for changing logging dynamically
+    def logger
+      @log
+    end
+
+    private
+
+    # Creates a Hash of AccountTracker objects, indexed by account name
+    def create_trackers
+      @trackers = Hash.new
+      @accounts.each do |name, account|
+        @log.debug "Setting up tracker for account #{name}"
+        @trackers[name] = AccountTracker.new(name, account,
+        {:delay => @delay, :callback => @callback, :logger => @log})
+      end
+    end
+
+  end
+end

data/lib/fog_tracker/util/string_underscore.rb

@@ -0,0 +1,10 @@
+# taken from ActiveSupport
+class String
+  def to_underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end

data/lib/fog_tracker/version.rb

@@ -0,0 +1,3 @@
+module FogTracker
+  VERSION = "0.1.0"
+end

data/lib/tasks/rspec.rake

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ['--color', '--format documentation', '-r ./spec/spec_helper.rb']
+end

data/spec/lib/fog_tracker/account_tracker_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module FogTracker
+
+    describe AccountTracker do
+
+      before(:each) do
+        @tracker = AccountTracker.new(
+          FAKE_ACCOUNT_NAME, FAKE_ACCOUNT, :logger => LOG
+        )
+      end
+
+      it "exposes its Hash of account information" do
+        @tracker.connection.should_not == nil
+      end
+      it "exposes the account name" do
+        @tracker.name.should == FAKE_ACCOUNT_NAME
+      end
+      it "exposes the connection to its Fog service" do
+        @tracker.account.should == FAKE_ACCOUNT
+      end
+      it "exposes the connection to its logger" do
+        @tracker.log.should_not == nil
+      end
+      it "exposes a collection of ResourceTrackers" do
+        @tracker.resource_trackers.size.should be > 0
+      end
+
+      describe '#start' do
+        it "sends update() to its ResourceTrackers" do
+          @tracker.resource_trackers.each do |resource_tracker|
+            resource_tracker.should_receive(:update)
+          end
+          @tracker.start
+          sleep THREAD_STARTUP_DELAY # wait for background thread to start
+        end
+      end
+
+      describe '#stop' do
+        it "sets running? to false" do
+          @tracker.start ; @tracker.stop
+          @tracker.running?.should be_false
+        end
+        it "kills its timer thread" do
+          @tracker.start ; @tracker.stop
+          @tracker.resource_trackers.first.should_not_receive(:update)
+          sleep THREAD_STARTUP_DELAY # wait to make sure no update()s are sent
+        end
+      end
+
+      describe '#running?' do
+        it "returns true if the AccountTracker is running" do
+          @tracker.start
+          @tracker.running?.should be_true
+        end
+        it "returns false if the AccountTracker is stopped" do
+          @tracker.running?.should be_false
+        end
+      end
+
+      describe '#tracked_types' do
+        it "returns a list of Resource types tracked for its account" do
+          @tracker.tracked_types.size.should be > 0
+          @tracker.tracked_types.first.should be_an_instance_of String
+        end
+      end
+
+    end
+
+end

data/spec/lib/fog_tracker/query/query_processor_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+module FogTracker
+  module Query
+
+    describe QueryProcessor do
+
+      QUERY['matching all Resources'] = '*::*::*::*'
+      QUERY['by account name']        = 'Fake Account \d+::*::*::*'
+      QUERY['by Fog Service']         = '*::FakeService::*::*'
+      QUERY['by Fog Provider']        = '*::*::FakeProvider::*'
+      QUERY['by Fog collection name'] = '*::*::*::fake_collection_type1'
+
+
+      it "should define a Query Pattern for parsing queries" do
+        QueryProcessor::QUERY_PATTERN.should_not == nil
+        QueryProcessor::QUERY_PATTERN.should be_an_instance_of(Regexp)
+      end
+
+      describe "#execute" do
+        context "with no discovered Resources" do
+          # Try each of the QUERY entries above against an empty set
+          QUERY.each do |name, query|
+            it "should return an empty Array for a query #{name}" do
+              QueryProcessor.new(
+                {FAKE_ACCOUNT_NAME => mock_account_tracker}, :logger => LOG
+              ).execute(query).should == []
+            end
+          end
+        end
+
+        context "with a pre-populated, diverse set of Resources" do
+          # Create a prepopulated QueryProcessor
+          NUMBER_OF_ACCOUNTS    = 8
+          RESOURCES_PER_ACCOUNT = 2
+          NUMBER_OF_COLLECTIONS = [5, NUMBER_OF_FAKE_RESOURCE_TYPES].min
+          before(:each) do
+            account_trackers =
+              (1..NUMBER_OF_ACCOUNTS).inject({}) do |t, account_index|
+                t["Fake Account #{account_index}"] = mock_account_tracker(
+                  NUMBER_OF_COLLECTIONS, RESOURCES_PER_ACCOUNT
+                ) ; t
+              end
+            @processor = QueryProcessor.new(account_trackers, :logger => LOG)
+          end
+          # Run the above QUERY entries against the prepopulated set
+          context "when running the query matching all Resources" do
+            it "should return all Resources" do
+              @processor.execute(QUERY['matching all Resources']).size.should ==
+                NUMBER_OF_ACCOUNTS * NUMBER_OF_COLLECTIONS * RESOURCES_PER_ACCOUNT
+            end
+          end
+          context "when running a query by account name" do
+            it "should return all Resources for that account only" do
+              @processor.execute(QUERY['by account name']).size.should ==
+                NUMBER_OF_ACCOUNTS * NUMBER_OF_COLLECTIONS * RESOURCES_PER_ACCOUNT
+              @processor.execute('wrong account::*::*::*').size.should == 0
+            end
+          end
+          context "when running a query by Fog service name" do
+            it "should return all Resources for that service only" do
+              @processor.execute(QUERY['by Fog Service']).size.should ==
+                NUMBER_OF_ACCOUNTS * NUMBER_OF_COLLECTIONS * RESOURCES_PER_ACCOUNT
+              @processor.execute('*::wrong service::*::*').size.should == 0
+            end
+          end
+          context "when running a query by Fog provider name" do
+            it "should return all Resources for that provider only" do
+              @processor.execute(QUERY['by Fog Provider']).size.should ==
+                NUMBER_OF_ACCOUNTS * NUMBER_OF_COLLECTIONS * RESOURCES_PER_ACCOUNT
+                @processor.execute('*::*::wrong provider::*').size.should == 0
+            end
+          end
+          context "when running a query by Fog collection name" do
+            it "should return all Resources for that collection only" do
+              @processor.execute(QUERY['by Fog collection name']).size.should ==
+                NUMBER_OF_ACCOUNTS * RESOURCES_PER_ACCOUNT
+              @processor.execute('*::*::*::wrong collection').size.should == 0
+              true
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/fog_tracker/resource_tracker_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module FogTracker
+
+    describe ResourceTracker do
+
+      before(:each) do
+        @account_tracker = mock_account_tracker
+        @tracker = ResourceTracker.new(
+          FAKE_COLLECTION, @account_tracker
+        )
+      end
+
+      it "exposes a collection of Fog objects" do
+        @tracker.collection.should == []
+      end
+
+      describe '#update' do
+        it "refreshes its resource collection from its AccountTracker" do
+          @account_tracker.connection.should_receive(FAKE_COLLECTION)
+          @tracker.update
+        end
+      end
+    end
+
+end

data/spec/lib/fog_tracker/tracker_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module FogTracker
+  describe Tracker do
+
+    ACCOUNTS = {
+      "fake account" => {
+        :provider                 => 'AWS',
+        :service                  => 'Compute',
+        :credentials => {
+          :aws_access_key_id      => 'X',
+          :aws_secret_access_key  => 'X'
+        }, :exclude_resources     => [ :spot_requests ]
+      }
+    }
+
+    before(:each) do
+      @tracker = Tracker.new(ACCOUNTS, :logger => LOG)
+    end
+
+    it "exposes a Hash of account information" do
+      @tracker.accounts.should == ACCOUNTS
+    end
+    it "exposes a Logger object for reporting its activity" do
+      @tracker.logger.should == LOG
+    end
+
+    describe '#types_for_account' do
+      it "returns an array of collection names for the given account" do
+        [ "addresses", "flavors", "images", "key_pairs", "security_groups",
+          "servers", "snapshots", "tags", "volumes"].each do |collection|
+            @tracker.types_for_account("fake account").should include(collection)
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+Bundler.require # Load all gems and libs
+
+# Require RSpec support files. Logging is configured there
+support_files = Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")]
+support_files.sort.each {|f| require f}
+
+# RSpec configuration block
+RSpec.configure do |config|
+  config.mock_with :rspec   # == Mock Framework
+  #config.fixture_path = "#{::Rails.root}/spec/fixtures"
+end

data/spec/support/_configure_logging.rb

@@ -0,0 +1,6 @@
+# Setup a global Logger for all tests
+LOG_LEVEL = ::Logger::WARN
+LOG = FogTracker.default_logger(STDOUT)
+LOG.info "Logging configured in #{File.basename __FILE__}."
+LOG.level = LOG_LEVEL
+#ActiveRecord::Base.logger = LOG  # Uncomment for ActiveRecord outputs

data/spec/support/_mocks.rb

@@ -0,0 +1,100 @@
+require 'fog'
+Fog.mock!
+
+# Establish some constants
+module FogTracker
+  FAKE_COLLECTION = 'servers'
+  FAKE_ACCOUNT_NAME = 'Fake EC2 Account'
+  FAKE_ACCOUNT = {
+    :provider     => 'AWS',
+    :service      => 'Compute',
+    :polling_time => 10,
+    :credentials  => {
+      :aws_access_key_id => "fake user",
+      :aws_secret_access_key => 'fake password'
+    },
+    :exclude_resources => [
+      :spot_requests,   # No Fog mocks for this resource
+      #:account,
+      #:flavors,
+      #:images,
+      #:addresses,
+      #:volumes,
+      #:snapshots,
+      #:tags,
+      #:servers,
+      #:security_groups,
+      #:key_pairs,
+      #:spot_instance_requests
+    ],
+  }
+  FAKE_ACCOUNTS = {FAKE_ACCOUNT_NAME => FAKE_ACCOUNT}
+  module Query
+    QUERY = {}  # Used in query_processor_spec.rb
+  end
+end
+
+# Create some fake Fog Resource and Collection Classes
+NUMBER_OF_FAKE_RESOURCE_TYPES = 30
+module Fog
+  module FakeService
+    module FakeProvider
+      (1..NUMBER_OF_FAKE_RESOURCE_TYPES).each do |class_index|
+        eval(%Q{
+            class FakeCollectionType#{class_index} ; end
+            class FakeResourceType#{class_index}
+              def collection ; FakeCollectionType#{class_index}.new end
+            end
+          })
+      end
+    end
+  end
+end
+
+def mock_account_tracker(num_collections = 1, resources_per_collection = 0)
+  fake_account_tracker = double('mock_account_tracker')
+  fake_account_tracker.stub(:account).and_return(Hash.new)
+  fake_account_tracker.stub(:name).and_return("fake account tracker")
+  fake_account_tracker.stub(:log).and_return(LOG)
+  fake_account_tracker.stub(:connection).and_return(mock_fog_connection)
+  # create an array of mock ResourceTrackers
+  trackers = (1..num_collections).map do |class_index|
+    mock_resource_tracker(
+      Fog::FakeService::FakeProvider.const_get("FakeResourceType#{class_index}"), 
+      resources_per_collection
+    )
+  end
+  fake_account_tracker.stub(:resource_trackers).and_return(trackers)
+  fake_account_tracker
+end
+
+def mock_fog_connection
+  fake_fog_connection = double('mock_fog_connection')
+  fake_fog_connection.stub(FogTracker::FAKE_COLLECTION).and_return([ 1, 2, 3 ])
+  fake_fog_connection
+end
+
+def mock_resource_tracker
+  fake_resource_tracker = double('mock_resource_tracker')
+  fake_resource_tracker.stub(:update)
+  fake_resource_tracker
+end
+
+def mock_fog_resource(resource_class)
+  fake_resource = resource_class.new
+  fake_collection_class =
+  fake_resource.stub(:collection).and_return(
+    collection_class.new
+  )
+  fake_resource
+end
+
+def mock_resource_tracker(resource_class, number_of_resources = 0)
+  fake_resource_tracker = double("mock_resource_tracker")
+  resources = Array.new
+  number_of_resources.times do
+    resources << resource_class.new
+  end
+  fake_resource_tracker.stub(:collection).and_return(resources)
+  fake_resource_tracker
+end

data/spec/support/_threading_support.rb

@@ -0,0 +1,3 @@
+# When message expectations are set for background threads, sometimes
+# they come in a after a short delay
+THREAD_STARTUP_DELAY = 1

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: fog_tracker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Benton Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-25 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: &2151920400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2151920400
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2151919380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151919380
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2151918740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151918740
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &2151917800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151917800
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &2151916140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151916140
+- !ruby/object:Gem::Dependency
+  name: guard-rake
+  requirement: &2151915260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151915260
+- !ruby/object:Gem::Dependency
+  name: ruby_gntp
+  requirement: &2151914080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151914080
+description: This gem peridically polls mutiple cloud computing services using the
+  fog gem, asynchronously updating the state of the resulting collections of Fog Resources.
+email:
+- benton@bentonroberts.com
+executables:
+- tracker
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- bin/tracker
+- config/accounts.yml.example
+- fog_tracker.gemspec
+- lib/fog_tracker.rb
+- lib/fog_tracker/account_tracker.rb
+- lib/fog_tracker/query/query_processor.rb
+- lib/fog_tracker/resource_tracker.rb
+- lib/fog_tracker/tracker.rb
+- lib/fog_tracker/util/string_underscore.rb
+- lib/fog_tracker/version.rb
+- lib/tasks/rspec.rake
+- spec/lib/fog_tracker/account_tracker_spec.rb
+- spec/lib/fog_tracker/query/query_processor_spec.rb
+- spec/lib/fog_tracker/resource_tracker_spec.rb
+- spec/lib/fog_tracker/tracker_spec.rb
+- spec/spec_helper.rb
+- spec/support/_configure_logging.rb
+- spec/support/_mocks.rb
+- spec/support/_threading_support.rb
+homepage: http://github.com/benton/fog_tracker
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3974745377539768248
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3974745377539768248
+requirements: []
+rubyforge_project: fog_tracker
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Tracks the state of cloud computing resources across multiple accounts with
+  multiple service providers
+test_files:
+- spec/lib/fog_tracker/account_tracker_spec.rb
+- spec/lib/fog_tracker/query/query_processor_spec.rb
+- spec/lib/fog_tracker/resource_tracker_spec.rb
+- spec/lib/fog_tracker/tracker_spec.rb
+- spec/spec_helper.rb
+- spec/support/_configure_logging.rb
+- spec/support/_mocks.rb
+- spec/support/_threading_support.rb