warningshot 0.9.4

data/lib/resolvers/integrity_resolver.rb

@@ -0,0 +1,69 @@
+require 'digest/md5'
+require 'digest/sha1'
+
+class WarningShot::IntegrityResolver
+  include WarningShot::Resolver
+  order  600
+  #disable!
+  
+  # Uses the same config files as file resolver, just add md5 field to config YML
+  branch :file
+  description 'Check file integrity via md5 or sha1 digest'
+  
+  # Define FileResource struct
+  FileResource = Struct.new(:source,:target,:digest,:digest_method) do
+    def exists?;File.exists?(target.path);end;
+  end
+    
+  cast String do |file|
+    FileResource.new URI.parse(''), URI.parse(file), nil, nil
+  end
+  
+  cast Hash do |file|
+    file[:source].sub!(/file:\/\//i,'') unless file[:source].nil?
+    
+    if file[:sha1] && file[:md5]
+      digest, digest_method = nil, nil
+    elsif file[:sha1]
+      digest, digest_method = file[:sha1], :sha1
+    elsif file[:md5]
+      digest, digest_method = file[:md5], :md5
+    end
+    
+    FileResource.new URI.parse(file[:source] || ''), URI.parse(file[:target]), digest, digest_method
+  end
+  
+  register(:test,{:name=>:sha1_digest,
+    :if => lambda{|dep| dep.digest_method == :sha1}
+  })do |dep|
+    dep_ok = (dep.exists? ? Digest::SHA1.hexdigest(File.read(dep.target.path)) == dep.digest : false)
+    
+    if dep_ok
+      logger.debug " ~ [PASSED] checksum #{dep.target}"
+    else
+      logger.warn " ~ [FAILED] checksum #{dep.target}"
+    end
+    
+    dep_ok
+  end
+  
+  register(:test,{:name=>:md5_digest,
+    :if => lambda{|dep| dep.digest_method == :md5}  
+  })do |dep|
+    dep_ok = (dep.exists? ? Digest::MD5.hexdigest(File.read(dep.target.path)) == dep.digest : false)
+
+    if dep_ok
+      logger.debug " ~ [PASSED] checksum #{dep.target}"
+    else
+      logger.warn " ~ [FAILED] checksum #{dep.target}"
+    end
+    
+    dep_ok
+  end
+  
+  register :test,{:name=>:no_digest,
+    :if => lambda{|dep| dep.digest_method == nil}
+  } do |dep|
+    true
+  end
+end

data/lib/resolvers/manual_resolver.rb

@@ -0,0 +1,19 @@
+class WarningShot::ManualResolver
+  include WarningShot::Resolver
+  order  10000
+  #disable!
+
+  branch :manual
+  description 'A glorified todo list of things that need to be resolved manually'
+      
+  #Encapsulated in a struct so Resolver doesn't freak out when we instance_eval #met & #resolved
+  NoteResource = Struct.new(:msg)
+    
+  cast do |note|
+    NoteResource.new(note)
+  end
+  
+  register :test do |dep|
+    logger.info " ~ #{dep.msg}"
+  end
+end

data/lib/resolvers/permission_resolver.rb

@@ -0,0 +1,72 @@
+# TODO It would be really sweet if there was a way for FileResolver, 
+#   DirectoryResolver, and SymlinkResolver inherited this functionality if
+#   mode, user, or group is set in its config file.
+class WarningShot::PermissionResolver
+  include WarningShot::Resolver
+  order  100
+  branch :permission
+  description 'Validates mode, user, and group permission on files and directories'
+     
+  module UnixPermissionsInterface;end;  
+  module WindowsPermissionsInterface;end;
+       
+  if WarningShot.platform != :windows
+    include WarningShot::PermissionResolver::UnixPermissionsInterface
+    #http://www.ruby-doc.org/core/classes/File/Stat.html
+    #http://www.ruby-doc.org/stdlib/libdoc/etc/rdoc/index.html
+    #http://www.ruby-doc.org/stdlib/libdoc/pathname/rdoc/index.html
+    #http://www.ruby-doc.org/stdlib/libdoc/fileutils/rdoc/index.html
+    #http://www.ruby-doc.org/core/classes/File.html#M002574
+  else
+    include WarningShot::PermissionResolver::WindowsPermissionsInterface
+  end     
+    
+  PermissionResource = Struct.new(:path,:target_mode,:target_user,:target_group,:recursive) do
+    def exists?
+      File.exist? self.path
+    end
+    
+    def correct_owner?
+      false
+    end
+    
+    def correct_group?
+      false
+    end
+    
+    def correct_mode?
+      false
+    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
+  end
+  
+  register :test do |resource|
+    _valid = resource.exists?
+    
+    if _valid
+      _valid &= resource.correct_owner?
+      _valid &= resource.correct_group?
+      _valid &= resource.correct_mode?
+    end
+    
+    if _valid
+      logger.debug " ~ [PASSED] permission: #{resource.path}"
+    else
+      logger.warn " ~ [FAILED] permission: #{resource.path}"
+    end
+      
+    _valid
+  end
+  
+  register :resolution do |resource|
+  end
+end

data/lib/resolvers/symlink_resolver.rb

@@ -0,0 +1,43 @@
+class WarningShot::SymlinkResolver
+  include WarningShot::Resolver
+
+  order       50
+  branch      :symlink
+  description 'Validates symlinks exist'
+       
+  SymlinkResource = Struct.new(:source,:target,:force) do
+    def link!;FileUtils.ln_s(self.source,self.target,:force=>self.force);end;
+    
+    def exists?
+      self.target ? File.symlink?(self.target) : false
+    end
+  end
+
+  cast String do |yaml|
+    SymlinkResource.new yaml, nil, false
+  end
+
+  cast Hash do |yaml|
+    use_force = yaml[:force].nil? ? true : yaml[:force]
+    SymlinkResource.new yaml[:source],yaml[:target], use_force
+  end
+  
+  # If the target wasn't specified, it doesn't exist
+  register :test do |dep| 
+    if symlink_found = dep.exists?
+      logger.debug " ~ [PASSED] symlink #{dep.target}"
+    else
+      logger.warn " ~ [FAILED] symlink #{dep.target}"
+    end
+    symlink_found
+  end
+
+  register :resolution do |dep|
+    begin
+      dep.link! if dep.target
+    rescue Errno::EEXIST, Errno::ENOTDIR => ex
+      logger.error " ~ Could not create symlink #{dep.source} => #{dep.target}"
+    end
+    dep.exists?
+  end
+end

data/lib/resolvers/url_resolver.rb

@@ -0,0 +1,76 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+module WarningShot
+  class UrlResolver
+    include WarningShot::Resolver
+    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(
+      :long         => "--vdepth",
+      :description  => "SSL Verify Peer Depth",
+      :name         => "ssl_verify_depth",
+      :default      => 5
+    )
+    
+    UrlResource = Struct.new(:uri)
+    cast do |dep|
+      UrlResource.new URI.parse(dep)
+    end
+    
+    register :test do |dep|
+      begin
+        http = Net::HTTP.new(dep.uri.host,dep.uri.port)
+        
+        if dep.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]
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            http.verify_depth = WarningShot::Config.configuration[: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)
+
+        valid_codes = WarningShot::Config.configuration[: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}"
+        else
+          logger.warn " ~ [FAILED] url #{dep.uri.to_s}"
+        end
+        
+        page_found
+      rescue Exception
+        logger.error "Could not reach #{dep.uri.to_s}"
+        false
+      end
+    end
+  end
+end

data/lib/warning_shot/config.rb

@@ -0,0 +1,132 @@
+# I pretty much goinked this from merb, you love merb, merb loves you.
+# http://merbivore.com
+
+module WarningShot
+  class Config
+  
+    class << self
+      def defaults
+        @defaults ||= {
+          :environment  => 'development',
+          :resolve      => false,
+          :config_paths => ['.'  / 'config' / 'warningshot', '~' / '.warningshot'],
+          :application  => '.',
+          :log_path     => '.' / 'log' / 'warningshot.log',
+          :log_level    => :info,
+          :growl        => false,
+          :verbose      => false,
+          :colorize     => true,
+          :resolvers    => ['~' / '.warningshot' / '*.rb']
+        }
+      end
+    
+      def use
+        @configuration ||= {}
+        yield @configuration
+        @configuration = defaults.merge(@configuration)
+      end
+    
+      def [](key)
+        (@configuration||={})[key]
+      end
+
+      def []=(key,val)
+        (@configuration||={})[key] = val
+        #@configuration[key] = val
+      end
+    
+      def setup(settings = {})
+        @configuration = defaults.merge(settings)
+      end
+    
+      attr_accessor :configuration
+    
+      def parse_args(argv = ARGV)
+        @configuration ||= {}
+        options = {}
+        options[:environment] = ENV["WARNING_SHOT_ENV"] if ENV["WARNING_SHOT_ENV"]
+      
+        WarningShot.parser.banner = <<-BANNER
+WarningShot v. #{WarningShot::VERSION}
+Dependency Resolution Framework
+
+Usage: warningshot [options]
+BANNER
+        WarningShot.parser.separator '*'*80
+        
+        WarningShot.parser.on("-e", "--environment=STRING", String, "Environment to test in","Default: #{defaults[:environment]}") do |env|
+          options[:environment] = env
+        end
+        WarningShot.parser.on("--resolve","Resolve missing dependencies (run as sudo)") do |resolve|
+          options[:resolve] = resolve
+        end
+        WarningShot.parser.on("-a","--app=PATH", String, "Path to application", "Default: #{defaults[:application]}") do |app|
+          options[:application] = app
+        end
+        WarningShot.parser.on("-c","--configs=PATH", String,"Path to config directories (':' seperated)","Default: #{defaults[:config_paths].join(':')}") do |config|
+          options[:config_paths] = config.split(':')
+        end
+        WarningShot.parser.on("-r","--resolvers=PATH", String,"Path to add'l resolvers (':' seperated)","Default: #{defaults[:resolvers].join(':')}") do |config|
+          options[:resolvers] = config.split(':')
+        end
+        WarningShot.parser.on("-t","--templates=PATH", String, "Generate template files", "Default: False") do |template_path|
+          template_path = options[:config_paths].first if template_path.nil? || template_path.empty?
+          WarningShot::TemplateGenerator.create(template_path)
+          exit
+        end
+        WarningShot.parser.on("-l","--log LOG", String, "Path to log file", "Default: #{defaults[:log_path]}") do |log_path|        
+          options[:log_path] = log_path
+        end
+        WarningShot.parser.on("--loglevel [LEVEL]",[:debug, :info, :warn, :error, :fatal], "Default: #{defaults[:log_level]}") do |log_level|
+          options[:log_level] = log_level
+        end
+        WarningShot.parser.on("-g", "--growl", "Output results via growl (Requires growlnotify)") do |growl|
+          options[:growl] = growl
+        end
+        WarningShot.parser.on("-v", "--[no-]verbose", "Output verbose information") do |verbose|
+          options[:verbose] = verbose
+        end
+        WarningShot.parser.on("-p", "--[no-]prettycolors", "Colorize output") do |colorize|
+          options[:colorize] = colorize
+        end
+        WarningShot.parser.on_tail("--version", "Show version"){ 
+          WarningShot.parser.parse!(argv)
+          WarningShot::Config.setup(options)
+          
+          WarningShot.load_app
+          WarningShot.load_addl_resolvers
+          
+          puts "WarningShot v. #{WarningShot::VERSION}"
+          puts "Installed resolvers:"
+            Resolver.descendents.each { |klass| 
+              puts "\n"
+              puts klass
+              puts "  Tests: #{klass.tests.length}, Resolutions: #{klass.resolutions.length} [#{klass.resolutions.empty? ? 'irresolvable' : 'resolvable'}]"
+              puts "  #{klass.description}" 
+              puts "  Command Line Options: #{klass.raw_cli_ext.inject([]){|m,c| m << c[:long]}.join(',')}" if klass.raw_cli_ext
+            }
+          exit
+        }
+        WarningShot.parser.on_tail("-h", "--help","Show this help message") { puts WarningShot.parser; exit } 
+        WarningShot.parser.on_tail("--debugger","Enable debugging") do
+          begin
+            require "ruby-debug"
+            Debugger.start
+            Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
+            puts "Debugger enabled"
+          rescue LoadError => ex
+            puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
+            exit
+          end
+        end
+        
+        WarningShot.parser.parse!(argv)
+        WarningShot::Config.setup(options)
+      rescue OptionParser::InvalidOption, OptionParser::InvalidArgument => op
+        puts op
+        puts WarningShot.parser #; exit;
+      end
+      
+    end #End self
+  end #End Config
+end#End WarningShot

data/lib/warning_shot/dependency_resolver.rb

@@ -0,0 +1,155 @@
+module WarningShot
+  class DependencyResolver
+    
+    attr_reader :environment, :dependency_tree, :resolvers
+    def initialize(config={})
+      @config           = config
+      @environment      = @config[:environment].to_sym
+      @dependency_tree  = {}
+      @resolvers        = []
+        
+      init_logger
+            
+      # Parsed yml files
+      self.load_configs
+      @dependency_tree.symbolize_keys!
+    end
+    
+    # gets stats of all resolvers
+    # @return [Hash] 
+    #   :passed, :failed, :resolved, :unresolved
+    #
+    # @api public
+    def stats
+      _stats = {
+        :passed => 0, :failed => 0, :resolved => 0, :unresolved => 0
+      }
+      
+      resolvers.each do |resolver|
+        _stats[:passed]     += resolver.passed.size
+        _stats[:failed]     += resolver.failed.size
+        _stats[:resolved]   += resolver.resolved.size
+        _stats[:unresolved] += resolver.unresolved.size
+      end
+      
+      _stats
+    end
+    
+    # initializes the logger
+    # 
+    # @api private
+    def init_logger
+      FileUtils.mkdir_p(File.dirname(File.expand_path(@config[:log_path]))) unless @config[:verbose]
+      
+      @logger = Logger.new(
+        @config[:verbose] ? STDOUT : @config[:log_path], 10, 1024000
+      )
+      _log_level = (@config[:log_level] || :debug).to_s.upcase
+
+      _formatter = WarningShot::LoggerFormatter.new
+      _formatter.colorize = @config[:colorize]
+
+      @logger.formatter = _formatter
+      @logger.level     = Object.class_eval("Logger::#{_log_level}")
+    end
+    
+    # runs all loaded resolvers
+    #
+    # @api private
+    def run
+      @logger.info "WarningShot v. #{WarningShot::VERSION}"
+      @logger.info "Environment: #{WarningShot.environment}; Application: #{WarningShot.framework}"
+      @logger.info "On host: #{WarningShot.hostname}"
+      
+      WarningShot::Resolver.descendents.each do |klass|
+        @logger.info "\n#{'-'*60}"
+
+        branch = @dependency_tree[klass.branch.to_sym]
+
+        if branch.nil?
+          @logger.info "No config file was found for branch #{klass.branch}"
+          next
+        end
+        
+        klass.logger = @logger
+        resolver = klass.new(*branch)
+
+        @resolvers << resolver
+        
+        @logger.info "#{resolver.class}; branch: #{klass.branch} [TESTING]"
+                
+        # Start test
+        klass.before_filters(:test).each{|p| p.call}
+        resolver.test!
+        klass.after_filters(:test).each{|p| p.call}
+        
+        @logger.info "Passed: #{resolver.passed.size} / Failed: #{resolver.failed.size}"
+
+        if WarningShot::Config.configuration[:resolve] && !klass.resolutions.empty?
+          @logger.info "#{resolver.class}; branch: #{klass.branch} [RESOLVING]"
+
+          klass.before_filters(:resolution).each{|p| p.call}
+          resolver.resolve! 
+          klass.after_filters(:resolution).each{|p| p.call}
+          
+          @logger.info "Resolved: #{resolver.resolved.size} / Unresolved: #{resolver.unresolved.size}"
+        end
+      end
+      
+      @logger.info "\nResults:"
+      stats.each {|k,v| @logger.info(" ~ #{k}: \t#{v}")}
+    end
+    
+    protected
+    # Loads configuration files
+    #
+    # @api protected
+    def load_configs
+      @config[:config_paths].each do |config_path|
+        #Parse the global/running env configs out of the YAML files.
+        Dir[config_path / WarningShot::ConfigExt].each do |config_file|
+          # Use WarningShot::ConfigExt & regexp on extension to make supporting add'l
+          # file types easier in the future
+          case File.extname(config_file)
+          when /.y(a)?ml/
+            parse_yml config_file
+          end
+        end
+      end
+    end
+    
+    # parses dependencies info from a yaml file
+    #
+    # @param file [String]
+    #   File path to parse
+    #
+    # @notes
+    #   yaml file should contain an array of configs, 
+    #     get name of each config set, find global and current environment
+    #     from set, merge into dependency_tree
+    #
+    # @api protected
+    def parse_yml(file)
+      #if only on branch is specified in a yaml file it may not come back as an array
+      branches  = YAML::load(File.open(file,'r'))
+      branches = [branches] unless branches.is_a? Array
+      
+      branches.each do |branch|
+        branch_name = branch[:branch]
+        dependency_tree[branch_name] ||= []
+
+        #Add current environment's configs to branch
+        current_env = branch[:environments][@environment]
+        @dependency_tree[branch_name].concat(current_env) unless current_env.nil?
+        
+        #Add global environment's configs to branch
+        global = branch[:environments][:global]
+        @dependency_tree[branch_name].concat(global) unless global.nil?
+        
+        #remove nil's if they made it into branch somehow (bad yaml probably)
+        @dependency_tree[branch_name].delete(nil)
+      end
+    end
+    
+  end
+end

data/lib/warning_shot/growl.rb

@@ -0,0 +1,14 @@
+module WarningShot
+  class Growl
+    
+    def Growl.say(msg)
+      img = WarningShot.dir_for(:images) / 'warning_shot_sml.png'
+
+      gmsg = %{growlnotify -t "WarningShot" -n "WarningShot" -m "#{msg}"}
+      gmsg += %{ --image #{img}} unless img.nil?
+
+      %x{#{gmsg}}
+    end
+
+  end
+end

data/lib/warning_shot/logger.rb

@@ -0,0 +1,27 @@
+module WarningShot
+  class LoggerFormatter < Logger::Formatter
+
+    ESCAPE_SEQ = {
+      "INFO"      => "\e[37m%s\e[0m",
+      "WARN"      => "\e[33m%s\e[0m",
+      "DEBUG"     => "\e[34m%s\e[0m",
+      "ERROR"     => "\e[31m%s\e[0m",
+      "FATAL"     => "\e[1m%s\e[0m"
+    }
+    
+    def call(severity, timestamp, progname, msg)
+      @colorize ? sprintf(ESCAPE_SEQ[severity],"#{msg}\n") : "#{msg}\n"
+    end
+    
+    def time_format=(fmt)
+      @time_format = fmt
+    end
+    
+    def colorize=(color)
+      @colorize = color
+    end
+        
+  end
+
+end
+