warningshot 0.9.4 → 0.9.5

data/lib/resolvers/gem_resolver.rb

@@ -1,58 +1,77 @@
-require 'rubygems/dependency_installer'
 class WarningShot::GemResolver
   include WarningShot::Resolver
+  add_dependency :core, 'rubygems'
+  add_dependency :core, 'rubygems/dependency_installer'
+  add_dependency :core, 'rubygems/uninstaller'
+  add_dependency :core, 'rubygems/dependency'
   
   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
-  )
+  DEFAULT_VERSION = ">= 0.0.0".freeze
+ 
+  cli("--gempath=PATH", String, "Alternate gem path ':' separated to check.  First in path is where gems will be installed") do |gpath|
+    options[:gem_path] = gpath
+  end
+  
+  cli("--update-sources","Update gem sources before installing") do |no_up_src|
+    options[:update_sources] = no_up_src
+  end
+ 
+  #cli("-m","--resolver-gems=GEMS", String,"Names of gems containing add'l resolvers (':' seperated)") do |resolver_gems|
+  #  options[:resolver_gems] = resolver_gems.split(':')
+  #end
+           
+  GemResource = Struct.new(:name,:version,:source) do
+    def installed?   
+      return !!(Gem.source_index.find_name(self.name, self.version).first)
+    end
     
-  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
+    def install!
+      orig_gem_sources = Gem.sources.clone
 
-      required_version = Gem::Requirement.new self.version
+      installer = Gem::DependencyInstaller.new({
+        :user_install => false,
+        :install_dir => Gem.path.first
+      })
 
-      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
+      begin
+        Gem.sources.replace(self.source.kind_of?(Array) ? self.source : [self.source]) if self.source 
+        installer.install(self.name,self.version)
+      rescue Gem::InstallError => ex
+        WarningShot::GemResolver.logger.error " ~ Could not install gem: #{self.name}:#{self.version}%s" % [self.source ? " from #{self.source}" : ""]
+      rescue Gem::GemNotFoundException => ex
+        WarningShot::GemResolver.logger.error " ~ Gem (#{self.name}:#{self.version}) was not found%s" % [self.source ? " from #{self.source}" : ""]
+      ensure
+        Gem.sources.replace orig_gem_sources # replace our gem sources
       end
-      installed
+
+      !installer.installed_gems.empty?
+    end
+    
+    def uninstall!
+      opts = {
+        :user_install => false,
+        :install_dir => Gem.path.first,
+        :version  => self.version
+      }
+      WarningShot::GemResolver.update_source_index(opts[:install_dir])
+      Gem::Uninstaller.new(self.name, opts).uninstall rescue false
     end
   end #End GemResource
   
-  cast(String){ |yaml| GemResource.new(yaml,DEFAULT_VERSION) }
-  cast(Hash){ |yaml| GemResource.new yaml[:name], yaml[:version] }
+  typecast(String){ |yaml| 
+    _ver = Gem::Requirement.new [DEFAULT_VERSION]
+    GemResource.new yaml, _ver 
+  }
+  
+  typecast(Hash){ |yaml| 
+    _ver = (yaml[:version].nil? || yaml[:version].empty?) ? DEFAULT_VERSION : yaml[:version]
+    _ver = Gem::Requirement.new [_ver]
+    GemResource.new yaml[:name], _ver, yaml[:source] 
+  }
     
   register :test do |dep|    
     if gem_found = dep.installed?
@@ -64,31 +83,33 @@ class WarningShot::GemResolver
   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?
+    dep.install!
   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
+    def update_source_index(*dirs)
+      spec_dirs = dirs.inject([]){|memo,dir| 
+        memo << File.join(File.expand_path(dir), 'specifications')
+      }
+            
+      Gem.send :class_variable_set, "@@source_index", Gem::SourceIndex.from_gems_in(*spec_dirs)
+      Gem::cache.refresh!
     end
   end
   
-  def initialize(*params)
+  def initialize(config,*params)
     super
-    WarningShot::GemResolver.load_paths
+    
+    Gem.configuration.update_sources = !!(self.config[:update_sources])
+    
+    if self.config.key?(:gem_path) && !self.config[:gem_path].nil?
+      gem_dirs = self.config[:gem_path].split(':')
+      gem_dirs.reverse.each do |path|
+        Gem.path.unshift File.expand_path(path)
+      end
+ 
+      WarningShot::GemResolver.update_source_index *gem_dirs
+    end
   end
+    
 end

data/lib/resolvers/integrity_resolver.rb

@@ -1,10 +1,9 @@
-require 'digest/md5'
-require 'digest/sha1'
-
 class WarningShot::IntegrityResolver
   include WarningShot::Resolver
+  add_dependency :core, 'digest/md5',   :disable => false, :unregister => [:md5_digest_test]
+  add_dependency :core, 'digest/sha1',  :disable => false, :unregister => [:sha1_digest_test]
+  
   order  600
-  #disable!
   
   # Uses the same config files as file resolver, just add md5 field to config YML
   branch :file
@@ -12,14 +11,14 @@ class WarningShot::IntegrityResolver
   
   # Define FileResource struct
   FileResource = Struct.new(:source,:target,:digest,:digest_method) do
-    def exists?;File.exists?(target.path);end;
+    def exists?;File.exists?(File.expand_path(target.path));end;
   end
     
-  cast String do |file|
+  typecast String do |file|
     FileResource.new URI.parse(''), URI.parse(file), nil, nil
   end
   
-  cast Hash do |file|
+  typecast Hash do |file|
     file[:source].sub!(/file:\/\//i,'') unless file[:source].nil?
     
     if file[:sha1] && file[:md5]
@@ -33,10 +32,10 @@ class WarningShot::IntegrityResolver
     FileResource.new URI.parse(file[:source] || ''), URI.parse(file[:target]), digest, digest_method
   end
   
-  register(:test,{:name=>:sha1_digest,
+  register(:test,{:name=>:sha1_digest_test,
     :if => lambda{|dep| dep.digest_method == :sha1}
   })do |dep|
-    dep_ok = (dep.exists? ? Digest::SHA1.hexdigest(File.read(dep.target.path)) == dep.digest : false)
+    dep_ok = (dep.exists? ? Digest::SHA1.hexdigest(File.read(File.expand_path(dep.target.path))) == dep.digest : false)
     
     if dep_ok
       logger.debug " ~ [PASSED] checksum #{dep.target}"
@@ -47,10 +46,10 @@ class WarningShot::IntegrityResolver
     dep_ok
   end
   
-  register(:test,{:name=>:md5_digest,
+  register(:test,{:name=>:md5_digest_test,
     :if => lambda{|dep| dep.digest_method == :md5}  
   })do |dep|
-    dep_ok = (dep.exists? ? Digest::MD5.hexdigest(File.read(dep.target.path)) == dep.digest : false)
+    dep_ok = (dep.exists? ? Digest::MD5.hexdigest(File.read(File.expand_path(dep.target.path))) == dep.digest : false)
 
     if dep_ok
       logger.debug " ~ [PASSED] checksum #{dep.target}"

data/lib/resolvers/manual_resolver.rb

@@ -1,15 +1,27 @@
 class WarningShot::ManualResolver
   include WarningShot::Resolver
   order  10000
-  #disable!
-
   branch :manual
+  
   description 'A glorified todo list of things that need to be resolved manually'
       
+  cli("--notes", "List all the notes in the manual branch") do |val|
+    WarningShot::Resolver.descendants.each{|d| d.disable!}
+    self.enable!
+    
+    config = WarningShot::Config.parse_args
+    config[:verbose] = true
+    
+    dr = WarningShot::DependencyResolver.new(config)    
+    dr.dependency_tree[:manual].each { |note| puts "~ #{note}" }
+    
+    exit
+  end
+  
   #Encapsulated in a struct so Resolver doesn't freak out when we instance_eval #met & #resolved
   NoteResource = Struct.new(:msg)
     
-  cast do |note|
+  typecast do |note|
     NoteResource.new(note)
   end
   

data/lib/resolvers/permission_resolver.rb

@@ -39,14 +39,12 @@ class WarningShot::PermissionResolver
     end
   end
   
-  cast Hash do |yaml|
-    _path       = yaml.delete(:path)
-    _mode       = yaml.delete(:mode)      || '0755'
-    _user       = yaml.delete(:user)      || 'nobody'
-    _group      = yaml.delete(:group)     || 'nobody'
-    _recursive  = yaml.delete(:recursive) || 'none'
-    
-    PermissionResource.new _path, _mode, _user, _group, _recursive
+  typecast Hash do |yaml|
+    PermissionResource.new  yaml.delete(:path), 
+                            yaml.delete(:mode)      || '0755',
+                            yaml.delete(:user)      || 'nobody',
+                            yaml.delete(:group)     || 'nobody',
+                            yaml.delete(:recursive) || 'none'
   end
   
   register :test do |resource|

data/lib/resolvers/symlink_resolver.rb

@@ -1,5 +1,6 @@
 class WarningShot::SymlinkResolver
   include WarningShot::Resolver
+  add_dependency :core, 'fileutils'
 
   order       50
   branch      :symlink
@@ -11,25 +12,29 @@ class WarningShot::SymlinkResolver
     def exists?
       self.target ? File.symlink?(self.target) : false
     end
+    
+    # Determines if link points at correct file
+    def correct?
+      File.identical? self.source, self.target
+    end
+      
   end
 
-  cast String do |yaml|
-    SymlinkResource.new yaml, nil, false
-  end
-
-  cast Hash do |yaml|
+  typecast do |yaml|
     use_force = yaml[:force].nil? ? true : yaml[:force]
-    SymlinkResource.new yaml[:source],yaml[:target], use_force
+    _src = File.expand_path yaml[:source]
+    _trg = File.expand_path yaml[:target]
+    SymlinkResource.new _src, _trg, use_force
   end
   
   # If the target wasn't specified, it doesn't exist
   register :test do |dep| 
-    if symlink_found = dep.exists?
+    if symlink_correct = dep.exists? && dep.correct?
       logger.debug " ~ [PASSED] symlink #{dep.target}"
     else
       logger.warn " ~ [FAILED] symlink #{dep.target}"
     end
-    symlink_found
+    symlink_correct
   end
 
   register :resolution do |dep|

data/lib/resolvers/url_resolver.rb

@@ -1,74 +1,61 @@
-require 'uri'
-require 'net/http'
-require 'net/https'
-
 module WarningShot
   class UrlResolver
     include WarningShot::Resolver
+    add_dependency :core, 'uri'
+    add_dependency :core, 'net/http'
+    add_dependency :core, 'net/https'
+    
     order  900
-    #disable!
 
     branch :url
     description 'Validates that URLs are reachable.'
     
-    cli(
-      :long         => "--strict",
-      :description  => "Success is only for 200 instead of 2xx|3xx",
-      :name         => "url_strict",
-      :default      => false
-    )
-    
-    cli(
-      :long         => "--rootcert",
-      :description  => "Path to root ca certificate",
-      :name         => "root_ca",
-      :default      => nil
-    )
+    cli("--strict", "Success is only for 200 instead of 2xx|3xx") do |val|
+      options[:url_strict] = val
+    end
     
-    cli(
-      :long         => "--vdepth",
-      :description  => "SSL Verify Peer Depth",
-      :name         => "ssl_verify_depth",
-      :default      => 5
-    )
+    cli("--rootcert", "Path to root ca certificate") do |val|
+      options[:root_ca] = val
+    end
     
-    UrlResource = Struct.new(:uri)
-    cast do |dep|
-      UrlResource.new URI.parse(dep)
+    cli("--vdepth", "SSL Verify Peer Depth") do |val|
+      options[:ssl_verify_depth] = val
     end
+            
+    typecast{ |dep| URI.parse(dep) }
     
-    register :test do |dep|
+    register :test do |uri,config|
       begin
-        http = Net::HTTP.new(dep.uri.host,dep.uri.port)
+        http = Net::HTTP.new(uri.host,uri.port)
         
-        if dep.uri.scheme == 'https'
+        if uri.scheme == 'https'
           http.use_ssl = true
 
-          if WarningShot::Config.configuration[:root_ca] && File.exist?(WarningShot::Config.configuration[:root_ca])
-            http.ca_file = WarningShot::Config.configuration[:root_ca]
+          if config[:root_ca] && File.exist?(config[:root_ca])
+            http.ca_file = config[:root_ca]
             http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-            http.verify_depth = WarningShot::Config.configuration[:ssl_verify_depth]
+            http.verify_depth = config[:ssl_verify_depth]
           else
             http.verify_mode = OpenSSL::SSL::VERIFY_NONE
           end
         end
         
-        dep.uri.path = '/' if dep.uri.path.empty?
-        resp = http.head(dep.uri.path)
+        uri.path = '/' if uri.path.empty?
+        resp = http.head(uri.path)
 
-        valid_codes = WarningShot::Config.configuration[:url_strict] ? /200/ : /^[23][0-9][0-9]$/
+        valid_codes = config[:url_strict] ? /200/ : /^[23][0-9][0-9]$/
         
         page_found = (resp.code =~ valid_codes)
-        
+
         if page_found
-          logger.debug " ~ [PASSED] url #{dep.uri.to_s}"
+          logger.debug " ~ [PASSED] url #{uri.to_s}"
         else
-          logger.warn " ~ [FAILED] url #{dep.uri.to_s}"
+          logger.warn " ~ [FAILED] url #{uri.to_s}"
         end
         
         page_found
-      rescue Exception
-        logger.error "Could not reach #{dep.uri.to_s}"
+      rescue Exception => ex
+        logger.error "Could not reach #{uri.to_s}"
         false
       end
     end

data/lib/warningshot.rb

@@ -1,16 +1,19 @@
-require 'rubygems'
 require 'fileutils'
 require 'yaml'
-require 'optparse'
 require 'logger'
 require 'set'
 require 'rbconfig'
+require 'optparse'
 
 # Load core extensions
-Dir.glob(File.join(File.dirname(__FILE__), "core_ext", "**", "*.rb")).each {|f| require f}
+Dir.glob(File.join(File.dirname(__FILE__), 'core_ext', '**', '*.rb')).each {|f| require f}
 
 # Load WarningShot
-Dir.glob(File.dirname(__FILE__) / "warning_shot" / "**" / "*.rb").each {|f| require f}
-
-# Load resolvers
-Dir.glob(File.dirname(__FILE__) / "resolvers" / "**" / "*.rb").each {|f| require f}
+require File.dirname(__FILE__) / 'warningshot' / 'warning_shot'
+require File.dirname(__FILE__) / 'warningshot' / 'version'
+require File.dirname(__FILE__) / 'warningshot' / 'config'
+require File.dirname(__FILE__) / 'warningshot' / 'logger'
+require File.dirname(__FILE__) / 'warningshot' / 'resolver' 
+require File.dirname(__FILE__) / 'warningshot' / 'dependency_resolver'
+require File.dirname(__FILE__) / 'warningshot' / 'growl'
+require File.dirname(__FILE__) / 'warningshot' / 'template_generator'