slashport 0.15.10

data/autotest/merb_rspec.rb

@@ -0,0 +1,165 @@
+# Adapted from Autotest::Rails, RSpec's autotest class, as well as merb-core's.
+require 'autotest'
+
+class RspecCommandError < StandardError; end
+
+# This class maps your application's structure so Autotest can understand what 
+# specs to run when files change.
+#
+# Fixtures are _not_ covered by this class. If you change a fixture file, you 
+# will have to run your spec suite manually, or, better yet, provide your own 
+# Autotest map explaining how your fixtures are set up.
+class Autotest::MerbRspec < Autotest
+  def initialize
+    super
+
+    # Ignore any happenings in these directories
+    add_exception %r%^\./(?:doc|log|public|tmp|\.git|\.hg|\.svn|framework|gems|schema|\.DS_Store|autotest|bin|.*\.sqlite3)% 
+    # Ignore SCM directories and custom Autotest mappings
+    %w[.svn .hg .git .autotest].each { |exception| add_exception(exception) }
+
+    # Ignore any mappings that Autotest may have already set up
+    clear_mappings
+
+    # Anything in /lib could have a spec anywhere, if at all. So, look for
+    # files with roughly the same name as the file in /lib
+    add_mapping %r%^lib\/(.*)\.rb% do |_, m|
+      files_matching %r%^spec\/#{m[1]}%
+    end
+
+    add_mapping %r%^spec/(spec_helper|shared/.*)\.rb$% do
+      all_specs
+    end
+
+    # Changing a spec will cause it to run itself
+    add_mapping %r%^spec/.*\.rb$% do |filename, _|
+      filename
+    end
+
+    # Any change to a model will cause it's corresponding test to be run
+    add_mapping %r%^app/models/(.*)\.rb$% do |_, m|
+      spec_for(m[1], 'model')
+    end
+
+    # Any change to global_helpers will result in all view and controller
+    # tests being run
+    add_mapping %r%^app/helpers/global_helpers\.rb% do
+      files_matching %r%^spec/(views|controllers|helpers)/.*_spec\.rb$%
+    end
+
+    # Any change to a helper will cause its spec to be run
+    add_mapping %r%^app/helpers/((.*)_helper(s)?)\.rb% do |_, m|
+      spec_for(m[1], 'helper')
+    end
+
+    # Changes to a view cause its spec to be run
+    add_mapping %r%^app/views/(.*)/% do |_, m|
+      spec_for(m[1], 'view')
+    end
+
+    # Changes to a controller result in its corresponding spec being run. If
+    # the controller is the exception or application controller, all
+    # controller specs are run.
+    add_mapping %r%^app/controllers/(.*)\.rb$% do |_, m|
+      if ["application", "exception"].include?(m[1])
+        files_matching %r%^spec/controllers/.*_spec\.rb$%
+      else
+        spec_for(m[1], 'controller')
+      end
+    end
+
+    # If a change is made to the router, run controller, view and helper specs
+    add_mapping %r%^config/router.rb$% do
+      files_matching %r%^spec/(controllers|views|helpers)/.*_spec\.rb$%
+    end
+
+    # If any of the major files governing the environment are altered, run
+    # everything
+    add_mapping %r%^config/(init|rack|environments/test).*\.rb|database\.yml% do 
+      all_specs
+    end
+  end
+
+  def failed_results(results)
+    results.scan(/^\d+\)\n(?:\e\[\d*m)?(?:.*?Error in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m)
+  end
+
+  def handle_results(results)
+    @failures      = failed_results(results)
+    @files_to_test = consolidate_failures(@failures)
+    @files_to_test.empty? && !$TESTING ? hook(:green) : hook(:red)
+    @tainted = !@files_to_test.empty?
+  end
+
+  def consolidate_failures(failed)
+    filters = Hash.new { |h,k| h[k] = [] }
+    failed.each do |spec, failed_trace|
+      if f = test_files_for(failed).find { |f| f =~ /spec\// }
+        filters[f] << spec
+        break
+      end
+    end
+    filters
+  end
+
+  def make_test_cmd(specs_to_runs)
+    [
+      ruby,
+      "-S",
+      spec_command,
+      add_options_if_present,
+      files_to_test.keys.flatten.join(' ')
+    ].join(' ')
+  end
+
+  def add_options_if_present
+    File.exist?("spec/spec.opts") ? "-O spec/spec.opts " : ""
+  end
+
+  # Finds the proper spec command to use. Precendence is set in the
+  # lazily-evaluated method spec_commands.  Alias + Override that in
+  # ~/.autotest to provide a different spec command then the default
+  # paths provided.
+  def spec_command(separator=File::ALT_SEPARATOR)
+    unless defined?(@spec_command)
+      @spec_command = spec_commands.find { |cmd| File.exists?(cmd) }
+
+      raise RspecCommandError, "No spec command could be found" unless @spec_command
+
+      @spec_command.gsub!(File::SEPARATOR, separator) if separator
+    end
+    @spec_command
+  end
+
+  # Autotest will look for spec commands in the following
+  # locations, in this order:
+  #
+  #   * default spec bin/loader installed in Rubygems
+  #   * any spec command found in PATH
+  def spec_commands
+    [File.join(Config::CONFIG['bindir'], 'spec'), 'spec']
+  end
+
+private
+
+  # Runs +files_matching+ for all specs
+  def all_specs
+    files_matching %r%^spec/.*_spec\.rb$%
+  end
+
+  # Generates a path to some spec given its kind and the match from a mapping
+  #
+  # ==== Arguments
+  # match<String>:: the match from a mapping
+  # kind<String>:: the kind of spec that the match represents
+  #
+  # ==== Returns
+  # String
+  #
+  # ==== Example
+  #   > spec_for('post', :view')
+  #   => "spec/views/post_spec.rb"
+  def spec_for(match, kind)
+    File.join("spec", kind + 's', "#{match}_spec.rb")
+  end
+end

data/bin/slashport

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "merb-core"
+require "optparse"
+
+class Options < Struct.new(:host, :port, :components, :configs, :logfile, :pidfile)
+  # empty
+end # class Options
+
+options = Options.new
+options.host = "0.0.0.0"
+options.port = 4000
+options.components = []
+options.configs = []
+options.logfile = "-"
+options.pidfile = "/tmp/slashport.pid"
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage; #{$0} [options}"
+
+  opts.on("-l HOST[:PORT]", "--listen HOST[:PORT]",
+          "Listen on specific host:port") do |v|
+
+    options.host, options.port = v.split(":")
+
+    if options.host == ""
+      options.host = "0.0.0.0"
+    end
+    options.port ||= 4000
+  end
+
+  opts.on("-c COMPONENT", "--component COMPONENT",
+          "Load specific component") do |v|
+    options.components << v
+  end
+
+  opts.on("-C COMPONENT_DIRECTORY", "--component-directory COMPONENT_DIRECTORY",
+          "Load components from a directory. All components must end in '.rb'") do |v|
+    if !File.directory?(v) or !File.readable?(v)
+      $stderr.puts "Path '#{v}' is not a directory or is not readable."
+      exit 1
+    end
+
+    Dir["#{v}/*.rb"].each do |file|
+      options.components << file
+    end
+  end
+
+  opts.on("-f CONFIG", "--config CONFIG",
+          "Read a config file") do |v|
+    options.configs << v
+  end
+
+  opts.on("-o LOGFILE", "--log LOGFILE", "Logfile to write to") do |v|
+    options.logfile = v
+  end
+
+  opts.on("-p PIDFILE", "--pidfile PIDFILE", "Pid file to write") do |v|
+    options.pidfile = v
+  end
+end
+
+parser.parse!
+
+merbdir = "#{File::dirname(__FILE__)}/../"
+Merb::Config.use do |c|
+  c[:host] = options.host
+  c[:port] = options.port
+  c[:adapter] = "mongrel"
+  c[:reload_classes] = false
+  c[:merb_root] = merbdir
+  c[:log_level] = :info
+  c[:name] = "slashport"
+  c[:environment] = nil
+  c[:exception_details] = true
+  c[:pid_file] = options.pidfile
+
+  if options.logfile == "-"
+    c[:log_stream] = STDOUT
+    c[:log_file] = nil
+  else
+    c[:log_file] = options.logfile
+    c[:log_stream] = nil
+  end
+end # Merb::Config.use
+
+Merb::BootLoader.after_app_loads do
+  options.components.each do |name|
+    require name
+  end
+
+  count = 0
+  options.configs.each do |name|
+    File.open(name).each do |line|
+      line.chomp!
+      puts "Config: #{line}"
+      next unless line =~ /^exec ([A-z0-9_-]+) ([A-z0-9_-]+) (.+)/
+      # format: exec <component> <section> <command ...>
+
+      component = $1
+      section = $2
+      cmd = $3
+      func = "#{component}_#{section}".tr("-", "_")
+      puts "Func: #{func}"
+      eval %{
+        module SlashPort
+          module ConfigGenerated
+            class #{component.upcase} < SlashPort::Component
+              attribute :name => "#{section}",
+                        :handler => :#{func},
+                        :doc => "#{func}"
+
+              def #{func}
+                return SlashPort::Exec.new("#{cmd}").to_tuple
+              end
+            end # class #{component.upcase}
+          end # module ConfigGenerated
+        end # module SlashPort
+      }
+
+      count += 1
+    end
+  end
+end # BootLoader.after_app_loads
+
+puts "Starting server"
+puts options.inspect
+
+Merb.start(Merb::Config.to_hash)

data/bin/slashportfetch

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "json"
+require "optparse"
+require "ostruct"
+require "net/http"
+require "uri"
+
+$: << "#{File::dirname(__FILE__)}/../lib"
+require "slashport"
+
+WARNING = 1
+CRITICAL = 2
+
+checks = []
+ignores = []
+options = OpenStruct.new
+options.filters = []
+options.port = 4000
+options.empty_results_is_ok = false
+argstr = ARGV.join(" ")
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options]"
+  opts.on("-f FILTER", "--filter FILTER", "Add a filter") do |v|
+    name, value = v.split("=", 2)
+    options.filters << [ name, value ]
+  end
+
+  opts.on("-i FILTER", "--ignore FILTER", "Ignore things matching a check") do |v|
+    check = SlashPort::Check.new_from_string(v)
+    if check == nil
+      puts "Invalid check #{v}"
+      exit 1
+    end
+    ignores << check
+  end
+  
+  opts.on("-h HOST[:PORT]", "--host HOST[:PORT]", "Host to query") do |v|
+    host, port = v.split(":",2)
+    port ||= 4000
+    options.host = host
+    options.port = port
+  end
+
+  opts.on("-c CHECK", "--check CHECK", "Output if CHECK succeeds") do |v|
+    check = SlashPort::Check.new_from_string(v)
+    if check == nil
+      puts "Invalid check #{v}"
+      exit 1
+    end
+    checks << check
+  end
+
+  opts.on("-r", "--empty-results-is-ok",
+             "Declare that having no matches to filters (after ignores are " \
+             "applied) is not an error") do |v|
+    options.empty_results_is_ok = true
+  end
+end
+parser.parse!
+
+if options.host == nil
+  puts "No --host specified."
+  exit 1
+end
+
+exitcode = 0
+fetcher = SlashPort::Fetcher.new(options.host, options.port)
+options.filters.each do |filter|
+  fetcher.add_filter(*filter)
+end
+
+matches = 0
+entries = 0
+fetcher.fetch.each do |entry|
+  # Skip if this entry matches any ignores
+  next if ignores.select { |check| check.match?(entry) }.length > 0
+  entries += 1
+
+  if checks.length == 0
+    puts entry.inspect
+    matches += 1
+  end
+
+  checks.each do |check|
+    if check.match?(entry)
+      puts "#{check} matches #{entry.inspect}"
+      exitcode = CRITICAL
+      matches += 1
+    end
+  end
+end
+
+if !options.empty_results_is_ok and entries == 0
+  puts "No entries found matching your filters, so there weren't any checks attempted."
+  puts "This is an error. If this is OK, then run with --empty-results-is-ok"
+  exitcode = CRITICAL
+end
+
+puts "#{matches} matches to #{$0} #{argstr}"
+
+exit exitcode

data/config/environments/development.rb

@@ -0,0 +1,15 @@
+Merb.logger.info("Loaded DEVELOPMENT Environment...")
+Merb::Config.use { |c|
+  c[:exception_details] = true
+  c[:reload_templates] = true
+  c[:reload_classes] = true
+  c[:reload_time] = 0.5
+  c[:ignore_tampered_cookies] = true
+  c[:log_auto_flush ] = true
+  c[:log_level] = :debug
+
+  c[:log_stream] = STDOUT
+  c[:log_file]   = nil
+  # Or redirect logging into a file:
+  # c[:log_file]  = Merb.root / "log" / "development.log"
+}

data/config/environments/production.rb

@@ -0,0 +1,10 @@
+Merb.logger.info("Loaded PRODUCTION Environment...")
+Merb::Config.use { |c|
+  c[:exception_details] = false
+  c[:reload_classes] = false
+  c[:log_level] = :error
+  
+  c[:log_file]  = Merb.root / "log" / "production.log"
+  # or redirect logger using IO handle
+  # c[:log_stream] = STDOUT
+}

data/config/environments/rake.rb

@@ -0,0 +1,11 @@
+Merb.logger.info("Loaded RAKE Environment...")
+Merb::Config.use { |c|
+  c[:exception_details] = true
+  c[:reload_classes]  = false
+  c[:log_auto_flush ] = true
+
+  c[:log_stream] = STDOUT
+  c[:log_file]   = nil
+  # Or redirect logging into a file:
+  # c[:log_file]  = Merb.root / "log" / "development.log"
+}

data/config/environments/staging.rb

@@ -0,0 +1,10 @@
+Merb.logger.info("Loaded STAGING Environment...")
+Merb::Config.use { |c|
+  c[:exception_details] = false
+  c[:reload_classes]    = false
+  c[:log_level]         = :error
+
+  c[:log_file]  = Merb.root / "log" / "staging.log"
+  # or redirect logger using IO handle
+  # c[:log_stream] = STDOUT
+}