warningshot 0.9.4

data/CONTRIBUTORS

@@ -0,0 +1,2 @@
+==== Contributors
+ * Cory ODaniel (I'm lonely)

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Cory ODaniel
+
+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/README

@@ -0,0 +1,101 @@
+WarningShot Dependency Resolution Framework
+ * Additional documentation @ http://github.com/coryodaniel/warningshot/wikis/
+
+==== How it works
+  * WarningShot - Factory class that creates and runs DependencyResolver
+  * DependencyResolver - Locates Resolver classes, creates a dependency tree, and matches resolvers to resolution branches
+  * Resolver - Class that can be included to create plugins.  Composed of tests and resolutions that can determine if a dependency was met, and if not, how to fix it
+  
+  
+==== Ruby API
+
+  - Configuring WarningShot
+  WarningShot::Config.use do |c|
+    c[:environment]  = 'development'
+    c[:resolve]      = false
+    c[:config_paths] = ['.'  / 'config' / 'warningshot']
+    c[:application]  = '.'
+    c[:log_path]     = '.' / 'log' / 'warningshot.log'
+    c[:log_level]    = :debug
+    c[:growl]        = false
+    c[:verbose]      = true
+    c[:colorize]     = true
+    c[:]
+  end
+  
+  - Interfacing with a DependencyResolver
+  dependency_resolver = WarningShot.fire!
+  dependency_resolver.stats                       # => Hash of statistics
+  
+  dependency_resolver.resolvers                   # => Array of all executed resolvers
+  
+  dependency_resolver.resolvers.first.dependencies #=> Set of all loaded dependencies
+  
+  dependency_resolver.resolver.first.passed     # => Array of passed dependencies
+  dependency_resolver.resolver.first.failed     # => Array of failed dependencies
+  dependency_resolver.resolver.first.unresolved # => Array of unresolved dependencies
+  dependency_resolver.resolver.first.resolved   # => Array of resolved dependencies
+  
+  - Callbacks
+  WarningShot.before do 
+    puts 'this would run before the DepenencyResolver was created in #fire!'
+  end
+  
+  WarningShot.after do
+    puts 'this would run after the DepenencyResolver was processed in #fire!'
+  end
+  
+  WarningShot::AnyResolverYouWant.before :test do
+    puts 'this would run before the #test! method on the chosen resolver'
+  end
+  
+  WarningShot::AnotherFunResolver.after :test do
+    puts 'this would run after the #test! method'
+  end
+  
+  WarningShot::AnotherResolver.before :resolution do
+    puts 'this would run before the #resolve! method'
+  end
+  
+  WarningShot::AnotherResolver.after :resolution do
+    puts 'this would run after the #resolve! method'
+  end
+  
+==== Components
+ * Ruby API
+ * Resolvers
+ * Config Files
+ 
+ 
+==== Using Config Files
+ * Coming Soon
+
+ 
+==== How the dependency tree works
+ * Coming Soon
+
+
+==== Extending WarningShot
+ * Writing a Resolver (Coming Soon)
+ * Modifying Resolvers at run-time (Coming Soon)
+
+
+==== Contributing
+ * Source available @: 
+    https://github.com/coryodaniel/warningshot/tree
+ 
+ * Bug reports / feature requests @:
+    http://warningshot.lighthouseapp.com/projects/17241-warningshot/overview
+ 
+ * Online Documentation available @: (eventually)
+
+ * RubyForge Project @:
+    http://rubyforge.org/projects/warning-shot/
+ 
+ * All modifications should also have applicable rpsecs
+    http://rspec.info/
+ 
+ * All code should be documented using YARD
+    http://yard.rubyforge.org/
+    A template is available file://./yardoc_template.txt
+    Generate Yardoc with: yardoc --output-dir ./doc/yard --private --protected --readme README

data/Rakefile

@@ -0,0 +1,28 @@
+require 'pathname'
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'spec/rake/spectask'
+require "rake/testtask"
+require "spec"
+require "spec/story"
+require 'spec/story/extensions/main'
+require "spec/rake/spectask"
+require "fileutils"
+
+NAME = 'warningshot'
+ROOT = Pathname(__FILE__).dirname.expand_path
+
+require 'lib/warning_shot/version'
+
+CLEAN.include ["**/.*.sw?", "pkg", "lib/*.bundle", "*.gem", "doc/","doc/", "test/output/*", "coverage", "cache"]
+Dir['tasks/*.rb'].each {|r| require r}
+
+
+##############################################################################
+# ADD YOUR CUSTOM TASKS IN /lib/tasks
+# NAME YOUR RAKE FILES file_name.rake
+##############################################################################

data/TODO

@@ -0,0 +1,148 @@
+Additional TODOS are at:
+http://warningshot.lighthouseapp.com
+
+====
+WarningShot should have its own set of config files so it can test its self (for WS Developers)
+
+Gems 
+ * Minigems option, prepares gems as minigems
+ 
+Binary Resolver
+ * Apt, Yum, Ports
+ * Random binaries like awk, vi, etc... (previously used `which BINARY`)
+ 
+Git, Svn Resolver
+
+ServicesResolver
+  * memcached, mysql, etc...
+
+IpTableResolver
+ * Confirms, sets up, and saves Iptables
+ 
+Connections Resolver
+ * test network connections
+ # ifconfig -a => active interfaces
+
+Hardware Resolver
+ * Determines if hardware requirements are met
+ 
+Script Resolver
+ * A scripting interface... was in old WS that enabled people to do most of this stuff
+    Should it just be left out since its so easy to extend?
+    
+MountResolver / NFSMount Resolver
+ * God knows.
+  
+QA Resolvers
+  * Rspec
+  * YSlow
+  * RCoverage
+  * Watir, etc etc
+
+  - :branch: quality
+    :environments:
+      :production:
+        - {attrib: "rspec", grade: ">98"}
+        - {attrib: "rcov", grade: ">90", rollback: "true"}
+
+
+  - :branch: yslow
+    :environments:
+      :production:
+        - {page: "http://example.com/login", grade: ">90"}
+        - {page: "http://example.com/index", grade: ">=99", rollback: "true"}
+ 
+Interfaces for Cap, Vertebra, and Vlad
+ 
+==== Old SHit.
+# This is old shit from a prototype i did of file/permissions resolver...
+#     http://www.workingwithrails.com/railsplugin/6146-open4-9-3
+#     http://codeforpeople.com/lib/ruby/open4/open4-0.9.3/README
+
+module WarningShot
+  class FileSystemResource
+  
+    def initialize(path_data)
+      @attributes = parse_params(path_data)
+    end
+  
+    def [](key)
+      return @attributes[key]
+    end
+
+    def []=(key,val)
+      return @attributes[key] = val
+    end
+  
+    def chown
+      status = Open4::popen4("sh") do |p,i,o,e|
+        command = ["chown"]
+        command.push "-R" if ["chown","both"].member? self[:recursive]
+        command.push "#{self[:user]}:#{self[:group]}"
+        command.push self[:target]
+      
+        i.puts command.join(" ")
+        i.close
+      end
+    
+      if status.exitstatus == 0
+        return true
+      else
+        raise Exception, "Could not chown:\n ~ #{@attributes.inspect}"
+      end
+    end
+  
+    def chmod
+      status = Open4::popen4("sh") do |p,i,o,e|
+        command = ["chmod"]
+        command.push "-R" if ["chmod","both"].member? self[:recursive]
+        command.push self[:mode]
+        command.push self[:target]
+      
+        i.puts command.join(" ")
+        i.close
+      end  
+    
+      if status.exitstatus == 0
+        return true
+      else
+        raise Exception, "Could not chmod:\n ~ #{@attributes.inspect}"
+      end
+    end
+  
+    private
+
+    def parse_params(path_data)
+      attributes = defaults
+  
+      #Make path_data a hash if it was passed as a string
+      path_data = {:target => path_data} if path_data.is_a? String
+  
+      attributes.merge! path_data.symbolize_keys!
+      orig_group = attributes[:group]
+  
+      #Group defaults to user
+      attributes[:group] = attributes[:user] if orig_group.nil? || orig_group.empty?
+  
+      #Expand source and dest paths
+      #attributes[:source]   = File.expand_path(attributes[:source]) unless attributes[:source].nil?
+      #attributes[:target]  = File.expand_path(attributes[:target])
+  
+      attributes[:recursive].downcase!
+  
+      return attributes
+    end
+
+    def defaults
+      {
+        :target       => nil,
+        :source        => nil,
+        :mode       => "0755",
+        :user       => "nobody",
+        :group      => "nobody",
+        :recursive  => "none"
+      }    
+    end
+  
+  end
+end

data/bin/warningshot

@@ -0,0 +1,19 @@
+#! /usr/bin/env ruby
+require 'warningshot'
+
+# Parse ARGV
+WarningShot::Config.parse_args
+
+# Initialize and run a new dependency resolver
+dep_resolver = WarningShot.fire!
+
+# Get the stats from the resolver
+stats = dep_resolver.stats
+
+# Growl the results if growl is on
+if WarningShot::Config[:growl]
+  WarningShot::Growl.say stats.to_a.join('/')
+end
+
+#Return an exit status based on number of unresolved dependencies
+exit(stats[:unresolved])

data/bin/ws-stage.bat

@@ -0,0 +1,3 @@
+# TODO
+#This should be a prestaging file for warning shot for Windows systems
+# If no ruby environment, downloads and installs latest stable environment and rubygems

data/bin/ws-stage.sh

@@ -0,0 +1,3 @@
+# TODO
+#This should be a prestaging file for warning shot for Unix systems
+# If no ruby environment, downloads and installs latest stable environment and rubygems

data/lib/core_ext/hash.rb

@@ -0,0 +1,14 @@
+class Hash
+  def symbolize_keys!
+    each do |k,v| 
+      sym = k.respond_to?(:to_sym) ? k.to_sym : k 
+      self[sym] = Hash === v ? v.symbolize_keys! : v 
+      self[sym] = Array === v ? v.each{|i| 
+        i.symbolize_keys! if i.is_a? Hash
+      }: v
+
+      delete(k) unless k == sym
+    end
+    self
+  end
+end

data/lib/core_ext/kernel.rb

@@ -0,0 +1,8 @@
+module Kernel
+  unless Kernel.respond_to?(:debugger)
+    #Provide a debugger method if the debugger is turned off, stops NoMethodError
+    def debugger
+      puts "=-=-=-=-=Debugger was request, but debugging is not enabled (warningshot --debugger)=-=-=-=-="
+    end
+  end
+end

data/lib/core_ext/object.rb

@@ -0,0 +1,7 @@
+class Object
+  class << self
+    def is_const_defined?(const)
+      Object.const_get const rescue false
+    end
+  end
+end

data/lib/core_ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def /(s)
+    File.join(self,s)
+  end
+end

data/lib/resolvers/core_lib_resolver.rb

@@ -0,0 +1,76 @@
+
+# Check to see if core lib packages are available
+#   Created due to issues with some Apt installs not installing all
+#   ruby core classes.  This is irresolvable, but at least gives you
+#   a heads up.
+
+class WarningShot::CoreLibResolver
+  include WarningShot::Resolver
+  
+  order 10
+  #disable!
+  description 'Checks that core ruby lib packages are available'
+  branch :core_lib
+  @@do_purge = false
+  
+  CoreLibResource = Struct.new(:lib)
+  cast do |dep|
+    CoreLibResource.new(dep)
+  end
+  
+  # optionally purge CoreLIb classes in memory
+  # The default behavior is to just remove the
+  # reference to loading the class from $".  Classes
+  # stay in memory but can be re-required without 
+  # returning false
+  #
+  # @param do_purge [Boolean] (Default: false)
+  #   Should classes be purged from memory.
+  def self.purge(do_purge=false)
+    @@do_purge = do_purge
+  end
+  
+  @@original_requires  = $".clone
+  @@original_classes   = Symbol.all_symbols.clone if @@do_purge
+  
+  register :test do |dep|
+    begin
+      require dep.lib
+      logger.debug " ~ Found core lib: #{dep.lib}"
+      WarningShot::CoreLibResolver.unload($" - @@original_requires)
+      WarningShot::CoreLibResolver.purge_classes(Symbol.all_symbols - @@original_classes) if @@do_purge
+      true
+    rescue LoadError => ex
+      false
+    end
+  end
+  
+  private
+ 
+  class << self
+    # removes files from $" so they can be re-required
+    #
+    # @param files [Array(String)]
+    #   files to remove
+    #
+    # @api private
+    def unload(files)
+      files.each do |req|
+        $".delete(req)
+      end
+    end
+  
+    # Undefines classes
+    #
+    # @param classes [Array(Symbol)]
+    #   classes to remove
+    #
+    # @api private
+    def purge_classes(classes)
+      classes.each do |klass|
+        Object.send(:remove_const, klass) if Object.is_const_defined? klass
+      end
+    end
+  
+  end
+end

data/lib/resolvers/directory_resolver.rb

@@ -0,0 +1,31 @@
+class WarningShot::DirectoryResolver
+  include WarningShot::Resolver
+  order       100
+  branch      :directory
+  
+  description 'Validates presence of directories'
+      
+  DirectoryResource = Struct.new(:path)  
+  cast do |path|
+    DirectoryResource.new File.expand_path(path)
+  end
+  
+  register :test do |dep|
+    dir_found = File.directory? dep.path
+    if dir_found
+      logger.debug " ~ [PASSED] directory: #{dep.path}"
+    else
+      logger.warn " ~ [FAILED] directory: #{dep.path}"
+    end
+    
+    dir_found
+  end
+  
+  register :resolution do |dep|
+    begin
+      FileUtils.mkdir_p dep.path
+    rescue Exception => ex
+      logger.error " ~ Could not create directory #{dep.path}"
+    end
+  end
+end

data/lib/resolvers/file_resolver.rb

@@ -0,0 +1,87 @@
+require 'fileutils'
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+# Tests and Heals File Dependencies
+#
+# @notes
+#   source is were the file can be resolved FROM
+#   target is were the file should exist
+class WarningShot::FileResolver
+  include WarningShot::Resolver
+  order  500
+
+  branch :file
+  description 'Validates presence of files'
+  
+  # Define FileResource struct
+  FileResource = Struct.new(:source,:target) do
+    def exists?;File.exists?(target.path);end;
+    def remove;File.unlink(target.path);end;
+  end
+    
+  cast String do |file|
+    FileResource.new URI.parse(''), URI.parse(file)
+  end
+  
+  cast Hash do |file|
+    file[:source].sub!(/file:\/\//i,'') unless file[:source].nil?
+    FileResource.new URI.parse(file[:source] || ''), URI.parse(file[:target])
+  end
+    
+  register :test, {:name => :file_check} do |file|
+    if file_found = file.exists?
+      logger.debug " ~ [PASSED] file: #{file.target.path}"
+    else
+      logger.warn " ~ [FAILED] file: #{file.target.path}"
+    end
+
+    file_found
+  end
+  
+  # Resolve files from target sources
+  # @notes
+  #   :if matches FILE_PROTOCOL or uri.scheme == nil
+  register(:resolution, { :name => :file_protocol,
+    :desc => "Resolves files from target sources",
+    :if => lambda { |file| 
+      !!(file.source.scheme =~ /file/i || file.source.scheme == nil)
+    }
+  }) do |file|    
+    begin
+      FileUtils.cp file.source.path, file.target.path
+    rescue Exception => ex
+      logger.error " ~ Could not restore file (#{file.target.path}) from #{file.source.path}"
+    end
+    file.exists?
+  end
+  
+  register(:resolution, { :name => :http_protocol,
+    :desc => "Resolves files from HTTP sources",
+    :if => lambda { |file| !!(file.source.to_s =~ /http(s)?/i)}
+  }) do |file|
+    begin
+      http = Net::HTTP.new(file.source.host,file.source.port)
+      http.use_ssl = (file.source.scheme == 'https')
+      file.source.path = '/' if file.source.path.empty?
+      resp = http.get(file.source.path)
+
+      File.open(file.target.path,"w+"){ |fs| fs.puts resp.body }  if resp.code == "200"
+    rescue Exception => ex  
+      logger.error " ~ Could not restore file (#{file.target.path}) from #{file.source.path}"
+    end
+    file.exists?
+  end
+=begin  
+  register(:resolution, {:name => :scp_protocol,
+    :desc => "Resolves files over SSH",
+    :if => lambda {|file| }
+  }){raise Exception, ' ~ SCP is not supported yet.'}
+  
+  register(:resolution, {:name => :ftp_protocol,
+    :desc => "Resolves files over FTP",
+    :if => lambda {|file| }
+  }){raise Exception, ' ~ FTP is not supported yet.'}
+=end
+end

data/lib/resolvers/gem_resolver.rb

@@ -0,0 +1,94 @@
+require 'rubygems/dependency_installer'
+class WarningShot::GemResolver
+  include WarningShot::Resolver
+  
+  order  100
+  branch :gem
+  description 'Installs ruby gems and their dependencies'
+
+  # Matches >, <, >=, <=
+  CONDITIONAL_RGX = /[^\d]*/.freeze
+  
+  # Matches digits in version
+  VERSION_RGX     = /[\d\.]+/.freeze
+  
+  # Default version to install
+  DEFAULT_VERSION = ">=0.0.0".freeze
+     
+  cli(
+    :long         => "--gempath",
+    :description  => "Alternate gem path ':' separated to check.  First in path is where gems will be installed",
+    :name         => "gem_path",
+    :default      => nil
+  )
+    
+  cli(
+    :long         => "--minigems",
+    :description  => "Not supported yet.",
+    :name         => "minigems",
+    :default      => false
+  )
+         
+  GemResource = Struct.new(:name,:version) do
+    def installed?
+      self.version ||= DEFAULT_VERSION
+      installed_versions = Gem::cache.search self.name
+      installed = false
+
+      required_version = Gem::Requirement.new self.version
+
+      installed_versions.each do |i_gem|
+        installed = case(required_version <=> Gem::Requirement.new(i_gem.version))
+        when 1,0
+          true
+        else
+          false
+        end
+        
+        break if installed
+      end
+      installed
+    end
+  end #End GemResource
+  
+  cast(String){ |yaml| GemResource.new(yaml,DEFAULT_VERSION) }
+  cast(Hash){ |yaml| GemResource.new yaml[:name], yaml[:version] }
+    
+  register :test do |dep|    
+    if gem_found = dep.installed?
+      logger.debug " ~ [PASSED] gem: #{dep.name}:#{dep.version}"
+    else
+      logger.warn " ~ [FAILED] gem: #{dep.name}:#{dep.version}"
+    end
+    gem_found
+  end
+  
+  register :resolution do |dep|
+    begin
+      dep_inst = Gem::DependencyInstaller.new({:install_dir => Gem.path.first})
+      dep_inst.install(dep.name,Gem::Requirement.new(dep.version))
+    rescue Exception => ex
+      logger.error " ~ Could not install gem: #{dep.name}:#{dep.version}"
+    end
+    dep.installed?
+  end
+  
+  class << self
+    # loads gem paths from WarningShot::Config
+    def load_paths
+      if WarningShot::Config.configuration.key?(:gem_path) && !WarningShot::Config.configuration[:gem_path].nil?
+        WarningShot::Config.configuration[:gem_path].split(":").reverse.each do |path|
+          Gem.path.unshift path
+        end
+        
+        Gem::cache.class.from_gems_in WarningShot::Config.configuration[:gem_path].split(":")
+        Gem::cache.refresh!
+      end
+    end
+  end
+  
+  def initialize(*params)
+    super
+    WarningShot::GemResolver.load_paths
+  end
+end