warning-shot 0.8.9

data/lib/warning_shot/dep_checker.rb

@@ -0,0 +1,584 @@
+
+module RippleNetworks
+  module WarningShot
+
+=begin rdoc
+  *Name*:: WarningShot
+  *Type*:: Class
+  *Namespace*:: RippleNetworks::WarningShot
+  *Description*:: Application dependency checker
+  *Inherits*:: None
+  *Mixins*:: None
+  *Extends*:: None
+  *RequiredGems*:: activerecord
+  *RequiredRubyLibraries*:: rubygems, fileutils, net/http, net/https, uri, yaml
+  *RequiredBinaries*:: which, growlnotify (if --growl option used)
+  *Authors*:: Cory O'Daniel
+  *Email*:: codaniel @nospam@ rippletv.com
+  *Last_Edited*:: Wed Dec 12 15:01:00 PST 2007
+=end
+    class DepChecker
+      include RippleNetworks::WarningShot
+      attr_reader :options, :warnings, :errors, :configs
+      
+      LIB_DIRECTORY = $:[0]
+      
+      #Config files to load
+      DEP_FILES = %w(urls preload classes binaries filesystem gems).freeze
+      
+      #Script folders to load
+      SCRIPTS = %w(ruby shell).freeze
+      
+      #Any mandatory options
+      MANDATORY_OPTIONS = %w().freeze
+      
+      # Ability to map additional corporate environments to applicable rails environment
+      ENVIRONMENT_MAP = {
+        "test"        => "test",
+        "development" => "development",
+        "qa"          => "development",
+        "stage"       => "production",
+        "production"  => "production"
+      }.freeze
+      
+      DEFAULTS = {
+        :dir          => '.',
+        :environment  => 'development',
+        :strict       => false,
+        :flush        => false,
+        :gems         => false,
+        :verbose      => false,
+        :growl        => false,
+        :templates    => false
+      }
+      
+      #Set up CLEAR and Windows Add'l requirement
+      if PLATFORM =~ /win32/
+        CLEAR = `cls`
+        begin
+          require 'Win32/Console/ANSI' 
+        rescue LoadError => e
+          puts "Run: 'gem install win32console' for colored output"
+        end
+      else
+        CLEAR = `clear`
+      end
+
+      
+      def initialize(options=DEFAULTS)  
+        @original_requires = $".clone
+        
+        ObjectSpace.define_finalizer(self, lambda{ @log_file.close unless @log_file.closed? }) 
+        
+        #Add directory information to defaults
+        DEFAULTS[:log]      = File.join(options[:dir],"log","warning_shot_#{options[:environment]}.log")
+        DEFAULTS[:configs]  = File.join(options[:dir],"config","warning_shot")
+             
+        @options = DEFAULTS.merge(options)
+        
+        #Map to correct running environment
+        @options[:environment] = ENVIRONMENT_MAP[@options[:environment]]
+        
+        #No errors or warnings
+        @errors = 0
+        @warnings = 0
+        
+        #initalize config file hash
+        @configs = {}
+        
+        #Flush log
+        flush_log! if @options[:flush]
+
+        #Open log
+        @log_file = File.open(@options[:log],"a+")
+
+        #Check dependencies
+        @which_installed = has_binary_prereqs?
+        puts CLEAR if @options[:verbose]
+      end
+
+=begin rdoc
+  *Name*:: DepChecker.has_binary?
+  *Access*:: public
+  *Description*:: Determine if an command line application is installed
+  *Last_Edited*:: Wed Dec 12 22:05:55 PST 2007
+  ===Parameters
+  * Name: app
+    * Description: name of cl tool  
+    * Datatype: string
+    * Default: None
+    * Required: True
+  ===Returns
+  *Description*:: whether it is installed or not
+  *Datatype*:: Boolean
+=end
+      def DepChecker.has_binary?(app)
+        %x{which #{app}}.match(/\bno/).nil?
+      end
+     
+      def unload
+        ($" - @original_requires).each do |req|
+          $".delete(req)
+        end
+      end
+     
+=begin rdoc
+  *Name*:: generate_templates
+  *Access*:: public
+  *Description*:: Generates all template files
+  *Last_Edited*:: Fri Dec 14 17:53:32 PST 2007
+  *Todo*:: Encapsulate as seperate private functions
+  ===Parameters
+  * Name: path
+    * Description:  path of creation
+    * Datatype: string
+    * Default: .
+    * Required: false
+=end
+      def DepChecker.generate_templates(path=".")
+        TemplateGenerator.new(path)      
+      end
+      
+      
+=begin rdoc
+  *Name*:: run
+  *Access*:: private
+  *Description*:: Run dependency checker
+  *Last_Edited*:: Wed Dec 12 16:04:15 PST 2007
+=end  
+      def run
+        start_time = Time.now
+        section
+          record("WarningShot (v. #{VERSION::INTERNAL}) - started @ #{start_time}")
+          check_framework
+          record("Environment: #{@options[:environment]}")
+          record("Framework: #{@framework}")
+
+        section("Loading YAML files:")    
+          ConfigParser.run(self)
+
+        section("Preloading classes")
+          class_loader("preload")
+
+        section("Checking class dependencies")
+          count = class_loader("classes")
+          record "#{count} classes not found",:error if count > 0
+
+        section("Checking binary dependencies")
+          count = check_binaries
+          record "#{count} binaries not found", :error if count > 0
+
+        section("Checking filesystem dependencies")
+          count = check_filesystem
+          record "#{count} files/directories not found", :error if count > 0
+
+        section("Checking URL dependencies")
+          count = check_urls
+          record "#{count} sites unavailable", :error if count > 0
+
+        section("Checking gem dependencies")
+          #Initialize gem handler
+          @gh = GemHandler.new(self.configs["gems"],self.options[:gems])
+
+          gem_errors = @gh.missing_gems.size
+
+          if @gh.missing_gems.size > 0          
+            record "#{gem_errors} gems not found: "
+            @gh.missing_gems.each do |gem,version|
+              record "\t#{gem} : #{version}"
+            end
+          end
+
+          if self.options[:gems] && @gh.errors.size > 0
+            gem_errors = @gh.errors.size
+            record "#{gem_errors} gems failed to install:"
+            @gh.errors.each do |gem,message|
+              record "\t#{gem}: #{message}"
+            end
+          end
+          
+          record("#{gem_errors} gems had errors", :error) if gem_errors > 0
+          @errors += gem_errors
+
+        section("Loading Ruby test scripts")
+          count = load_ruby_scripts
+          record("#{count} scripts failed to load",:error) if count > 0
+
+        section("Running Ruby test scripts")
+          count = test_ruby_scripts
+          record("#{count} scripts failed",:error) if count > 0
+
+        #section("Shell script dependencies")
+          #count = check_shell_scripts
+          #record("#{count} scripts failed",:error) if count > 0
+
+        section
+        section("RESULTS")
+          record("Total Warnings #{@warnings}",(@warnings > 0) ? :warning : :info)
+          record("Total Errors: #{@errors}",(@errors > 0) ? :error : :info)
+          record("Checked in #{Time.now.to_f-start_time.to_f}s",:info)
+        section
+
+        #Status via growlnotify
+        if @options[:growl]
+          #TODO Update to Red/Green ruby, instead of Rails Logo
+          if @errors == 0
+            growl("All Dependencies tests passed!","ruby_ok.png")
+          else
+            growl("#{@errors} failed dependencies!","ruby_fail.png")
+          end
+        end
+
+        unload
+        @log_file.close unless @log_file.closed?
+      end
+      
+      
+=begin rdoc
+  *Name*:: record
+  *Access*:: public
+  *Description*:: Record message to log
+  *Last_Edited*:: Wed Dec 12 15:37:21 PST 2007
+  ===Parameters
+  * Name: level
+    * Description: Message level :error, :warning, :info, :none
+    * Datatype: Symbol
+    * Default: :info
+    * Required: false
+=end
+      def record(msg,level=:none)
+        if [:error,:warning,:info,:fatal].include? level
+          msg = %{#{level.to_s.upcase}: #{msg}}
+        end
+
+        case level
+        when :error
+          @errors += 1
+        when :warning
+          @warnings += 1
+        end
+
+        @log_file.puts msg 
+
+        if @options[:verbose]
+          case level
+          when :info
+            msg = "\e[37m#{msg}\e[0m"
+          when :error
+            msg = "\e[31m#{msg}\e[0m"
+          when :warning
+            msg = "\e[33m#{msg}\e[0m"
+          when :fatal
+            msg = "\e[1m\e[5m#{msg}\e[0m"
+          end     
+          
+          puts msg
+
+          Kernel.exit if level == :fatal
+        end
+      end      
+      
+      
+      private 
+      
+=begin rdoc
+  *Name*:: check_framework
+  *Access*:: private
+  *Description*:: Determines framework
+  *Last_Edited*:: Mon Dec 17 11:24:59 PST 2007
+  *Note*:: This function is still pretty experimental.
+=end      
+      def check_framework
+        if defined?(RAILS_ROOT)
+          @framework = "RAILS"
+        elsif defined?(Merb)
+          @framework = "MERB"
+        else
+          @framework = "CONSOLE"
+        end
+      end
+    
+    
+=begin rdoc
+  *Name*:: growl
+  *Access*:: private
+  *Description*:: Sends msg via growlnotify
+  *Last_Edited*:: Wed Dec 12 19:47:34 PST 2007
+  ===Parameters
+  * Name: msg
+    * Description:  Message displayed
+    * Datatype: String
+    * Default: None
+    * Required: True
+  * Name: img
+    * Description:  path to image to display
+    * Datatype: String
+    * Default: nil
+    * Required: false
+=end
+      def growl(msg,img=nil)
+        gmsg = %{growlnotify -t "WarningShot" -n "WarningShot" -m "#{msg}"}
+        gmsg += %{ --image #{File.join(LIB_DIRECTORY,"..","images",img)}} unless img.nil?
+        %x{#{gmsg}}
+      end
+
+
+=begin rdoc
+  *Name*:: section
+  *Access*:: private
+  *Description*:: Display a section seperator
+  *Last_Edited*:: Mon Dec 17 10:45:52 PST 2007
+  ===Parameters
+  * Name: title
+    * Description:  Puts a title in the seperator
+    * Datatype: string
+    * Default: None
+    * Required: False
+=end
+      def section(title="")
+        record %{#{title.center(60,"-") }}
+      end
+    
+      
+=begin rdoc
+  *Name*:: has_binary_prereqs?
+  *Access*:: private
+  *Description*:: Determine if system has the `which` command
+  *Last_Edited*:: Wed Dec 12 15:19:53 PST 2007
+  *Todo*:: Find a better way!!!
+  ===Returns
+  *Description: Whether binaries prereqs are installed
+  *Datatype: Boolean
+=end
+      def has_binary_prereqs?
+    		if DepChecker.has_binary? "which"
+		  
+    		  if @options[:growl]
+    		    unless DepChecker.has_binary? "growlnotify"
+        		  record "Could not locate: `growlnotify`", :warning
+      		  end
+    	    end
+	        return true
+    		else
+    			record "Could not locate: `which`; required for binaries dependencies\n\tbinaries.yml will be skipped!!!", :error
+    			return false
+    		end
+      end
+
+
+=begin rdoc
+  *Name*:: flush_log!
+  *Access*:: private
+  *Description*:: Flushes log file if it exists
+  *Last_Edited*:: Wed Dec 12 15:04:11 PST 2007
+=end
+      def flush_log!
+        File.truncate(@options[:log],0) if File.exists? @options[:log]
+        #File.unlink @options[:log] if File.exists? @options[:log]
+        #FileUtils.touch @options[:log]
+      end
+      
+      
+=begin rdoc
+  *Name*:: class_loader
+  *Access*:: private
+  *Description*:: Loads classes for dependency checking or as a resource for DepChecker
+  *Last_Edited*:: Wed Dec 12 20:18:13 PST 2007
+  ===Parameters
+  * Name: mode
+    * Description: Mode of operation (preload | classes)
+    * Datatype: String
+    * Default: :preload
+    * Required: false
+=end
+      def class_loader(mode="preload")
+        errors = 0
+        
+        @configs[mode].each do |klass|
+          begin
+            #TODO Mute output from requires, ie "puts"
+            #@@@ Rescue block doesn't seem to be catching error.
+            require klass
+            record("FOUND: #{klass}")
+          rescue LoadError => e
+            case mode
+              when "preload"
+                record("NOT FOUND: #{klass}",:fatal)
+              when "classes"
+                errors += 1
+                record("NOT FOUND: #{klass}",:error)
+              else
+                record("Invalid class_loader mode",:fatal)
+            end
+          end
+        end
+        
+        return errors
+      end
+      
+      
+=begin rdoc
+  *Name*:: check_binaries
+  *Access*:: private
+  *Description*:: check for installed binaries
+  *Last_Edited*:: Wed Dec 12 22:03:13 PST 2007
+=end
+      def check_binaries
+        errors = 0
+        
+        if @which_installed
+          @configs["binaries"].each do |binary|
+            if DepChecker.has_binary? binary
+              record("INSTALLED: #{binary}")
+            else
+              errors += 1
+              record("NOT FOUND: #{binary}",:error)
+            end
+          end
+        
+        end
+        
+        return errors
+      end
+      
+      
+=begin rdoc
+  *Name*:: check_filesystem
+  *Access*:: private
+  *Description*:: check for files and directories
+  *Last_Edited*:: Thu Dec 13 11:22:03 PST 2007
+=end      
+      def check_filesystem
+        errors = 0
+        
+        @configs["filesystem"].each do |path|
+          if File.file?(path)
+    				record("FOUND (file): #{path}")
+    			elsif File.directory?(path)
+    				record("FOUND (directory): #{path}")
+    			elsif File.exists?(path)
+            record("FOUND: #{path}")
+    			else
+            record("NOT FOUND: #{path}", :error)
+    				errors += 1
+    			end
+        end
+        
+        return errors
+      end
+    
+    
+=begin rdoc
+  *Name*:: check_urls
+  *Access*:: private
+  *Description*:: 
+  *Last_Edited*:: Thu Dec 13 12:24:06 PST 2007
+=end
+      def check_urls
+        errors = 0
+        
+        @configs["urls"].each do |site|
+          uri = URI.parse site.chomp
+          http = Net::HTTP.new(uri.host, uri.port)
+          #TODO mute SSL "peer certificate verification" message
+          http.use_ssl = true if uri.scheme == "https"
+          uri.path = "/" if uri.path.empty?
+          
+          begin
+            response, data = http.get(uri.path)
+            http_code = response.code.to_i
+            
+            if @options[:strict] && http_code == 200
+              record("CONNECTED (#{http_code}): #{uri}")
+            elsif http_code >= 200 && http_code < 300
+              record("CONNECTED (#{http_code}): #{uri}", ((http_code != 200)? :warning : nil))
+            else
+              errors += 1
+              record("UNAVAILABLE (#{http_code}): #{uri}", :error)
+            end
+          rescue Exception => e
+            errors += 1
+            record("An exception occurred: #{e.message} while connecting to: #{uri}", :error)
+          end
+        end
+        
+        return errors
+      end
+      
+      def load_ruby_scripts
+        errors = 0
+        
+        begin
+          scripts_path = File.join(@options[:configs],"scripts","ruby","")
+          
+          #Load PreScript
+          pre_script = File.join(scripts_path,"pre.rb")  
+          begin        
+            require pre_script if File.exists? pre_script
+          rescue
+            record "Failed to load: #{pre_script}", :fatal
+            errors +=1
+          end
+          
+          Dir.new(scripts_path).each { |script|
+            #Dont get hidden files or pre_,post_ scripts
+            unless script =~ /^\./i || script =~ /^post_/i || script =~ /^pre_/i || script =~ /^pre.rb/i || script =~ /^post.rb/i
+
+              #Require a file and its pre_, post_
+              [File.join(scripts_path,%{pre_#{script}}),
+                File.join(scripts_path,script),
+                File.join(scripts_path,%{post_#{script}})].each {|s|
+                  begin
+                    require s if File.exists? s
+                  rescue
+                    record "Failed to load: #{s}",:fatal
+                    errors +=1
+                  end
+              }
+              
+            end
+          }
+          
+          #Load PostScript
+          post_script = File.join(scripts_path,"post.rb")
+          begin
+            require post_script if File.exists? post_script
+          rescue
+            record "Failed to load: #{pre_script}", :fatal
+            errors +=1
+          end
+        rescue Exception => e
+           record e
+           record "Script directory not found, try running 'warning-shot --templates=PATH'", :warning
+        end 
+        
+        return errors
+      end
+      
+      def test_ruby_scripts
+        errors = 0
+        #Execute #run on each child
+        TestScript.children.each do |test|
+          begin
+            result, message = test.run()
+            
+            unless result
+              record %{#{test.class} test failed!},:error
+              record(%{\tMessage from #{test.class} test: #{message}}) unless message.nil?
+              errors += 1
+            else
+              record(%{#{test.class} test passed!},:info)
+              record(%{\tMessage from #{test.class} test: #{message}}) unless message.nil?
+            end
+          rescue Exception => e
+            record %{An error occured while processing: #{test.class}\n#{e}}, :fatal
+            errors += 1
+          end
+        end
+        
+        return errors
+      end
+      
+    end
+  end
+end