warningshot 0.9.4 → 0.9.5

data/CHANGELOG

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+
+= 0.9.5
+2009-01-22 	Cory ODaniel <warningshot@coryodaniel.com>
+	* RubyGems 1.3 Support
+	* Various bug fixes / improvements in GemResolver
+	* Added RSpecs	
+	* Fixed bug that crashed WS if YAML was malformed

data/CONTRIBUTORS

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

data/README

@@ -1,16 +1,89 @@
 WarningShot Dependency Resolution Framework
  * Additional documentation @ http://github.com/coryodaniel/warningshot/wikis/
 
+
+==== Installing WarningShot
+  WarningShot installs a little differently than most gems.  WarningShot itself has NO gem dependencies.  Gems become
+  a dependency based on what Plugins/Resolvers you have installed.  By default WarningShot will not install any additional gems.
+  When using WarningShot if a gem is missing that is needed for a feature you are using you will receive a warning that the gem
+  is missing.  Optionally you can list and build all of warningshots dependencies from the command line.
+  
+  sudo gem install warningshot
+  warningshot --list-deps (list all resolvers and their dependencies)
+  warningshot --build-deps (install all gems that resolvers are dependent on)
+  
+  This method provides a minimalist WarningShot.  WarningShot's dependencies essentially change depending on what you use
+  it for.  Thats neat, not a lot of extra gems that you don't need installed being installed.
+  
+
+==== Terminology
+  * Resolver
+    A class that includes WarningShot::Resolver.  It should have the ability to test and resolve a type
+    of dependency
+      
+  * Configuration
+    The current configuration the WarningShot instance is running under.
+    Configurations can be created with WarningShot::Config
+    
+  * Dependency
+    A dependency is an entry in a machine recipe.  A dependency should consist of some means of identifying the
+    dependency and optionally (but suggested) have some way of describing how it should be resolved.
+      Ex: File Dependencies specify where the file should be located, and where WarningShot can download it if it
+          does not exist
+  
+  * Test
+    Tests are blocks that are registered in resolver.  They are a means of determining if a dependency is met.  Multiple tests
+    can be written, and may also have conditions as to whether they should run or not (a test could be environment
+    specific for instance).  WarningShot will run the first test that it can based on any conditions provided.  
+    Tests should always return a Boolean value
+  
+  * Resolution
+    Resolutions are like tests in every way except instead of determine if a dependency has been met, they actually
+    repair or resolve the dependency.  The gem resolver can install missing gems and the file resolver can download
+    missing files
+  
+  * Machine Recipes / Application Recipes
+    A machine recipe is one or more dependency branches, the default file type is YAML, but that is configurable
+    within warningshot.  A machine recipe can specify the complete configuration of a computer/application or just one
+    aspect of it.  Example:  warningshot --templates will create a separate machine recipe for each branch supported.
+    In the wiki (http://github.com/coryodaniel/warningshot/wikis/example-merbnginx-app-recipe-once-aptquality-dependencies-are-supported)
+    is an example of a machine recipe that specifies dependencies of files, gems, apt binaries, etc.
+    
+  * DependencyTree
+    After WarningShot locates all of the Machine Recipes they are parsed into the dependency tree.  The dependency
+    tree is a large hash of branch names to raw hashes parsed from the Machine Recipes (YAML).
+    
+  * DependencyBranch
+    A specific type of dependency within the dependency tree.  Examples include, :file, :gem, :directory
+  
 ==== 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
   
-  
+==== Command Line Examples
+For a list of all flags do: warningshot --help
+
+	- Details on Resolvers
+		warningshot --version
+		
+	- Loading specific resolvers
+		warningshot --oload=gem,file 												# => Only gem and file resolvers will be run
+		warningshot --pload=directory,file 									# => Only loads specified gems and loads in specified order
+		warningshot --resolvers=/path/to/my/resolvers/*.rb 	# => Glob to find additional resolvers
+
+	- Creating Recipe templates
+		warningshot --templates=./path/to/where/you/want/templates
+		
+	- Warningshot's Dependencies
+		warningshot --list-deps															# => Depedencies per Resolver
+		warningshot --build-deps														# => Installs everything a full fledged warningshot needs
+
+
 ==== Ruby API
 
   - Configuring WarningShot
-  WarningShot::Config.use do |c|
+  config = WarningShot::Config.create do |c|
     c[:environment]  = 'development'
     c[:resolve]      = false
     c[:config_paths] = ['.'  / 'config' / 'warningshot']
@@ -24,7 +97,7 @@ WarningShot Dependency Resolution Framework
   end
   
   - Interfacing with a DependencyResolver
-  dependency_resolver = WarningShot.fire!
+  dependency_resolver = WarningShot.fire!(config)
   dependency_resolver.stats                       # => Hash of statistics
   
   dependency_resolver.resolvers                   # => Array of all executed resolvers
@@ -67,7 +140,7 @@ WarningShot Dependency Resolution Framework
  * Config Files
  
  
-==== Using Config Files
+==== Using Machine Recipes
  * Coming Soon
 
  
@@ -77,6 +150,7 @@ WarningShot Dependency Resolution Framework
 
 ==== Extending WarningShot
  * Writing a Resolver (Coming Soon)
+    * Kernel#require vs Resolver#add_dependency
  * Modifying Resolvers at run-time (Coming Soon)
 
 
@@ -87,13 +161,19 @@ WarningShot Dependency Resolution Framework
  * Bug reports / feature requests @:
     http://warningshot.lighthouseapp.com/projects/17241-warningshot/overview
  
- * Online Documentation available @: (eventually)
-
+ * Online Documentation available @:
+    http://github.com/coryodaniel/warningshot/wikis
+    
  * RubyForge Project @:
     http://rubyforge.org/projects/warning-shot/
  
  * All modifications should also have applicable rpsecs
     http://rspec.info/
+    
+ * A dummy gem has been created for testing the GemResolver
+    https://rubyforge.org/projects/ws-dummy/
+    http://github.com/coryodaniel/ws-dummy/tree/master
+    gem install ws-dummy
  
  * All code should be documented using YARD
     http://yard.rubyforge.org/

data/Rakefile

@@ -16,13 +16,14 @@ require "fileutils"
 NAME = 'warningshot'
 ROOT = Pathname(__FILE__).dirname.expand_path
 
-require 'lib/warning_shot/version'
+require 'lib/warningshot'
+require 'lib/warningshot/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
+# ADD YOUR CUSTOM TASKS IN ./tasks
+# NAME YOUR RAKE FILES file_name.rb
 ##############################################################################

data/TODO

@@ -1,148 +1,2 @@
 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
+http://warningshot.lighthouseapp.com

data/bin/warningshot

@@ -1,19 +1,23 @@
 #! /usr/bin/env ruby
-require 'warningshot'
 
-# Parse ARGV
-WarningShot::Config.parse_args
+#pre scan ARGV for pload oload
+if ARGV.grep(/(o|p)load/i).empty?
+  require 'warningshot/suite'
+else
+  require 'warningshot'
+end
+
+# Create a config hash
+config = WarningShot::Config.parse_args
 
 # Initialize and run a new dependency resolver
-dep_resolver = WarningShot.fire!
+dep_resolver = WarningShot.fire!(config)
 
 # 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
+WarningShot::Growl.say stats.to_a.join('/') if config[:growl]
 
 #Return an exit status based on number of unresolved dependencies
 exit(stats[:unresolved])

data/lib/resolvers/core_lib_resolver.rb

@@ -6,15 +6,14 @@
 
 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|
+  typecast do |dep|
     CoreLibResource.new(dep)
   end
   

data/lib/resolvers/directory_resolver.rb

@@ -6,7 +6,7 @@ class WarningShot::DirectoryResolver
   description 'Validates presence of directories'
       
   DirectoryResource = Struct.new(:path)  
-  cast do |path|
+  typecast do |path|
     DirectoryResource.new File.expand_path(path)
   end
   

data/lib/resolvers/file_resolver.rb

@@ -1,8 +1,3 @@
-require 'fileutils'
-require 'uri'
-require 'net/http'
-require 'net/https'
-
 # Tests and Heals File Dependencies
 #
 # @notes
@@ -10,6 +5,12 @@ require 'net/https'
 #   target is were the file should exist
 class WarningShot::FileResolver
   include WarningShot::Resolver
+  
+  add_dependency :core, 'fileutils'
+  add_dependency :core, 'uri'
+  add_dependency :core, 'net/http',   :disable => false, :unregister => [:http_protocol_resolver]
+  add_dependency :core, 'net/https',  :disable => false, :unregister => [:https_protocol_resolver]
+  
   order  500
 
   branch :file
@@ -17,20 +18,20 @@ class WarningShot::FileResolver
   
   # Define FileResource struct
   FileResource = Struct.new(:source,:target) do
-    def exists?;File.exists?(target.path);end;
-    def remove;File.unlink(target.path);end;
+    def exists?;File.exists?(File.expand_path(target.path));end;
+    def remove;File.unlink(File.expand_path(target.path));end;
   end
     
-  cast String do |file|
+  typecast String do |file|
     FileResource.new URI.parse(''), URI.parse(file)
   end
   
-  cast Hash do |file|
+  typecast 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|
+  register :test, {:name => :file_test} do |file|
     if file_found = file.exists?
       logger.debug " ~ [PASSED] file: #{file.target.path}"
     else
@@ -43,23 +44,39 @@ class WarningShot::FileResolver
   # 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",
+  register(:resolution, { :name => :file_protocol_resolver,
+    :desc => "Resolves files via local filesystem",
     :if => lambda { |file| 
-      !!(file.source.scheme =~ /file/i || file.source.scheme == nil)
+      !!(file.source.scheme =~ /file/i || file.source.scheme == nil && !file.source.path.empty?)
     }
   }) do |file|    
     begin
-      FileUtils.cp file.source.path, file.target.path
+      FileUtils.cp File.expand_path(file.source.path), File.expand_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)}
+  register(:resolution, { :name => :http_protocol_resolver,
+    :desc => "Resolves files via HTTP",
+    :if => lambda { |file| !!(file.source.to_s =~ /http/i)}
+  }) do |file|
+    begin
+      http = Net::HTTP.new(file.source.host,file.source.port)
+      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
+  
+  register(:resolution, { :name => :https_protocol_resolver,
+    :desc => "Resolves files via HTTPS",
+    :if => lambda { |file| !!(file.source.to_s =~ /https/i)}
   }) do |file|
     begin
       http = Net::HTTP.new(file.source.host,file.source.port)
@@ -73,6 +90,7 @@ class WarningShot::FileResolver
     end
     file.exists?
   end
+  
 =begin  
   register(:resolution, {:name => :scp_protocol,
     :desc => "Resolves files over SSH",