zuk-picnic 0.7.999.20090212

data/lib/picnic/cli.rb

@@ -0,0 +1,165 @@
+require 'optparse'
+
+require 'picnic'
+require 'picnic/conf'
+require 'picnic/server'
+
+module Picnic
+  # Provides a command-line interface for your app. 
+  # This is useful for creating a 'bin' file for launching your application.
+  #
+  # Usage example (put this in a file called 'foo'):
+  #
+  #   #!/usr/bin/env ruby
+  #
+  #   require 'rubygems'
+  #   require 'picnic'
+  #
+  #   require 'picnic/cli'
+  #
+  #   cli = Picnic::Cli.new(
+  #     'foo',
+  #     :app_path => "/path/to/foo.br"
+  #   )
+  #
+  #   cli.handle_cli_input   
+  #
+  # Also see the ServiceControl class for info on how to use your cli script
+  # as a service.
+  class Cli
+    attr_accessor :app, :options
+    
+    # Creates a new command-line interface handler.
+    #
+    # +app+:: The name of the application. This should match the name of the
+    #         binary, which by default is expected to be in the same directory
+    #         as the service control script.
+    # +options+:: A hash overriding default options. The options are:
+    #             +app_file+:: The path to your application's main Ruby file.
+    #                          By default this is expected to be <tt>../lib/<app>.rb</tt>
+    #             +pid_file+:: Where the app's PID file (containing the app's
+    #                          process ID) should be placed. By default this is
+    #                          <tt>/etc/<app>/<app>.pid</tt>
+    def initialize(app, options = {})
+      @app = app
+      
+      @options = options || {}
+      @options[:app_file]   ||= File.expand_path(File.dirname(File.expand_path($0))+"/../lib/#{app}.rb")
+      @options[:app_name]   ||= app
+      @options[:app_module] ||= app.capitalize
+      @options[:pid_file]   ||= "/etc/#{app}/#{app}.pid"
+      @options[:conf_file]  ||= nil
+    end
+    
+    # Parses command line options given to the script.
+    def handle_cli_input
+      if File.exists? options[:app_file]
+        # try to use given app base path
+        $APP_ROOT = File.dirname(options[:app_file]).gsub(/\/(lib|bin)\/?$/, '')
+      else
+        require 'rubygems'
+        
+        # fall back to using gem installation
+        matches = Gem::source_index.find_name(app)
+        raise LoadError, "#{app} gem doesn't appear to be installed!" if matches.empty?
+        
+        gem_spec = matches.last
+        $APP_ROOT = gem_spec.full_gem_path
+        
+        gem(app)
+      end
+      
+      $: <<  $APP_ROOT+"/lib"
+      
+      $PID_FILE     = @options[:pid_file]
+      $CONFIG_FILE  = @options[:conf_file]
+      $VERBOSE      = @options[:verbose]
+      
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} app.rb"
+        opts.define_head "#{File.basename($0)}, the microframework ON-button for ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+        opts.separator ""
+        opts.separator "Application options:"
+      
+        opts.on("-d", "--daemonize", "Run daemonized in the background") do
+          $DAEMONIZE = true
+        end
+        opts.on("-c", "--config FILE", "Use this config file (default is /etc/<app>/config.yml)") do |c| 
+          puts "Using config file #{c.inspect}"
+          $CONFIG_FILE = c
+        end
+        opts.on("-P", "--pid_file FILE", "Path to pid file (used only when running daemonized; default is /etc/<app>/<app>.pid)") do |p| 
+          if $DAEMONIZE && !File.exists?(p)
+            puts "Using pid file #{p.inspect}"
+            $PID_FILE = p
+          elsif File.exists?(p)
+            puts "The pid file already exists.  Is #{app} running?\n" +
+              "You will have to first manually remove the pid file at '#{p}' to start the server as a daemon."
+            exit 1
+          else
+            puts "Not running as daemon.  Ignoring pid option"
+          end
+        end
+        
+        # optoinal block with additonal opts.on() calls specific to your application
+        if @options[:extra_cli_options]
+          @options[:extra_cli_options].call(opts)
+        end   
+      
+        opts.separator ""
+        opts.separator "Picnic options:"
+      
+        # No argument, shows at tail.  This will print an options summary.
+        # Try it and see!
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+        
+        opts.on_tail("-v", "--version", "Show the application's version number") do
+          require "#{$APP_ROOT}/lib/#{app}/version.rb"
+          app_mod = Object.const_get(@options[:app_module])
+          puts "#{app}-#{app_mod::VERSION::STRING}"
+          exit
+        end
+      end
+      
+      begin
+        opts.parse! ARGV
+      rescue OptionParser::ParseError => ex
+        STDERR.puts "!! #{ex.message}"
+        puts "** use `#{File.basename($0)} --help` for more details..."
+        exit 1
+      end
+      
+      
+      $CONF = Picnic::Conf.new
+      $CONF.load_from_file(app, $APP_ROOT, $CONF_FILE)
+      
+      if $DAEMONIZE
+        # TODO: use Process.daemon when RUBY_VERSION >= 1.9
+        
+        exit if fork
+        Process.setsid
+        exit if fork
+        
+        Dir.chdir $APP_ROOT
+        File.umask 0000
+        
+        STDIN.reopen "/dev/null"
+        STDOUT.reopen "/dev/null", "a"
+        STDERR.reopen "/dev/null", "a"
+        
+        if $PID_FILE
+          File.open($PID_FILE, 'w'){ |f| f.write("#{Process.pid}") }
+          at_exit { File.delete($PID_FILE) if File.exist?($PID_FILE) }
+        end
+      end
+      
+      server = Picnic::Server::Base.new($CONF, [options[:app_file]])
+      server.start
+    end
+  end
+end
+
+

data/lib/picnic/conf.rb

@@ -0,0 +1,135 @@
+require 'active_support'
+
+module Picnic
+  # Provides an interface for accessing your Picnic app's configuration file.
+  #
+  # Usage example:
+  #
+  #   # Load the configuration from /etc/foo/config.yml
+  #   Conf.load('foo')
+  #
+  #   # The contents of config.yml is now available as follows:
+  #   puts Conf[:server]
+  #   puts Conf[:authentication][:username]
+  #   # ... etc.
+  class Conf
+    def initialize(from_hash = {})
+      @conf = HashWithIndifferentAccess.new(from_hash)
+      
+      @conf[:log] ||= HashWithIndifferentAccess.new
+      @conf[:log].merge!(:file => STDOUT, :level => 'DEBUG')
+      
+      @conf[:uri_path] ||= "/"
+    end
+    
+    # Read a configuration option.
+    #
+    # For example:
+    #   puts Conf[:server]
+    def [](key)
+      @conf[key]
+    end
+    
+    # Another way of reading a configuration option.
+    #
+    # The following statements are equivalent:
+    #   puts Conf[:server]
+    #   puts Conf.server
+    def method_missing(method, *args)
+      self[method]
+    end
+    
+    # Needs to be defined when we have a custom method_missing().
+    def respond_to?(method)
+      (@conf.stringify_keys.keys).include?(method.to_s) || super
+    end
+    
+    # Returns the path to your application's example config file.
+    #
+    # The example config file should be in the root directory of
+    # your application's distribution package and should be called
+    # <tt>config.example.yml</tt>. This file is used as a template
+    # for your app's configuration, to be customized by the end
+    # user. 
+    def example_config_file_path(app_root)
+      "#{app_root}/config.example.yml"
+    end
+    
+    # Copies the example config file into the appropriate
+    # configuration directory.
+    #
+    # +app_name+:: The name of your application. For example: <tt>foo</tt>
+    # +app_root+:: The path to your application's root directory. For example: <tt>/srv/www/camping/foo/</tt>
+    # +dest_conf_file:: The path where the example conf file should be copied to.
+    #                   For example: <tt>/etc/foo/config.yml</tt>
+    def copy_example_config_file(app_name, app_root, dest_conf_file)
+      require 'fileutils'
+          
+      example_conf_file = example_config_file_path(app_root)
+      
+      puts "\n#{app_name.to_s.upcase} SERVER HAS NOT YET BEEN CONFIGURED!!!\n"
+      puts "\nAttempting to copy sample configuration from '#{example_conf_file}' to '#{dest_conf_file}'...\n"
+      
+      unless File.exists? example_conf_file 
+        puts "\nThe example conf file does not exist! The author of #{app_name} may have forgotten to include it. You'll have to create the config file manually.\n"
+        exit 2
+      end
+      
+      begin
+        dest_conf_file_dir = File.dirname(dest_conf_file)
+        FileUtils.mkpath(dest_conf_file_dir) unless File.exists? dest_conf_file_dir
+        FileUtils.cp(example_conf_file, dest_conf_file)
+      rescue Errno::EACCES
+        puts "\nIt appears that you do not have permissions to create the '#{dest_conf_file}' file. Try running this command using sudo (as root).\n"
+        exit 2
+      rescue => e
+        puts "\nFor some reason the '#{dest_conf_file}' file could not be created (#{e})."
+        puts "You'll have to copy the file manually. Use '#{example_conf_file}' as a template.\n"  
+        exit 2
+      end
+      
+      puts "\nA sample configuration has been created for you in '#{dest_conf_file}'. Please edit this file to" +
+        " suit your needs and then run #{app_name} again.\n"
+      exit 1
+    end
+    
+    # Loads the configuration from the YAML file for the given app.
+    #
+    # <tt>app_name</tt> should be the name of your app; for example: <tt>foo</tt>
+    # <tt>app_root</tt> should be the path to your application's root directory; for example:: <tt>/srv/www/camping/foo/</tt>
+    # [<tt>config_file</tt>] can be the path to an alternate location for the config file to load
+    #
+    # By default, the configuration will be loaded from <tt>/etc/<app_name>/config.yml</tt>.
+    def load_from_file(app_name, app_root, config_file = nil)
+      conf_file = config_file || "/etc/#{app_name.to_s.downcase}/config.yml"
+      
+      puts "Loading configuration for #{app_name.inspect} from #{conf_file.inspect}..."
+      
+      begin
+        conf_file = etc_conf = conf_file
+        unless File.exists? conf_file 
+          # can use local config.yml file in case we're running non-gem installation
+          conf_file = "#{app_root}/config.yml"
+        end
+      
+        unless File.exists? conf_file  
+          copy_example_config_file(app_name, app_root, etc_conf)
+        end
+        
+        loaded_conf = HashWithIndifferentAccess.new(YAML.load_file(conf_file))
+        
+        @conf.merge!(loaded_conf)
+        
+      rescue => e
+          raise "Your #{app_name} configuration may be invalid."+
+            " Please double-check check your config.yml file."+
+            " Make sure that you are using spaces instead of tabs for your indentation!!" +
+            "\n\nTHE UNDERLYING ERROR WAS:\n#{e.inspect}"
+      end
+    end
+    
+    def merge_defaults(defaults)
+      @conf = HashWithIndifferentAccess.new(HashWithIndifferentAccess.new(defaults).merge(@conf))
+    end
+  end
+end

data/lib/picnic/controllers.rb

@@ -0,0 +1,4 @@
+module Picnic
+  module Controllers
+  end
+end

data/lib/picnic/logger.rb

@@ -0,0 +1,41 @@
+require 'logger'
+
+module Picnic
+  module Logger
+    
+    # Makes available a Logger instance under the global $LOG variable.
+    def init_global_logger!
+      logdev = ($CONF && $CONF.log[:file]) || STDOUT
+      $LOG = Picnic::Logger::Base.new(logdev)
+      $LOG.level = Picnic::Logger::Base.const_get(($CONF && $CONF.log[:level]) || 'DEBUG')
+      
+      puts "Initialized global logger to #{logdev.inspect}."
+    end
+    module_function :init_global_logger!
+    
+    class Base < ::Logger
+      def initialize(logdev, shift_age = 0, shift_size = 1048576)
+        begin
+          super
+        rescue Exception
+          puts "WARNING: Couldn't create Logger with output '#{logdev}'. Logger output will be redirected to STDOUT."
+          super(STDOUT, shift_age, shift_size)
+        end
+      end
+    
+      def format_message(severity, datetime, progrname, msg)
+        (@formatter || @default_formatter).call(severity, datetime, progname, msg)
+      end
+    end
+  
+    # Custom log formatter used by the Picnic Logger.
+    class Formatter < ::Logger::Formatter
+      Format = "[%s#%d] %5s -- %s: %s\n"
+      
+      def call(severity, time, progname, msg)
+        Format % [format_datetime(time), $$, severity, progname,
+          msg2str(msg)]
+      end
+    end
+  end
+end

data/lib/picnic/server.rb

@@ -0,0 +1,98 @@
+require 'camping/server'
+
+module Picnic::Server
+  class Base < Camping::Server::Base
+    def start
+      handler, conf = case @conf.server
+      when "console"
+        ARGV.clear
+        IRB.start
+        exit
+      when "mongrel"
+        prep_mongrel
+      when "webrick"
+        prep_webrick
+      end
+      
+      rapp =  apps.first
+
+      if @conf.uri_path
+        rapp = Rack::URLMap.new(@conf.uri_path => rapp)
+      end
+      
+      rapp = Rack::ContentLength.new(rapp)
+      rapp = FixContentLength.new(rapp)
+      rapp = Rack::Lint.new(rapp)
+      rapp = Camping::Server::XSendfile.new(rapp)
+      rapp = Rack::ShowExceptions.new(rapp)
+      
+      handler.run(rapp, conf) 
+    end
+    
+    
+    private
+    
+    def prep_webrick
+      handler = Rack::Handler::WEBrick
+      options = {
+        :BindAddress => @conf.bind_address || "0.0.0.0",
+        :Port => @conf.port
+      }
+      
+      cert_path = @conf.ssl_cert
+      key_path = @conf.ssl_key || @conf.ssl_cert
+        # look for the key in the ssl_cert if no ssl_key is specified
+        
+      unless cert_path.nil? && key_path.nil?
+        raise "The specified certificate file #{cert_path.inspect} does not exist or is not readable. " +
+          " Your 'ssl_cert' configuration setting must be a path to a valid " +
+          " ssl certificate." unless
+            File.exists? cert_path
+        
+        raise "The specified key file #{key_path.inspect} does not exist or is not readable. " +
+          " Your 'ssl_key' configuration setting must be a path to a valid " +
+          " ssl private key." unless
+            File.exists? key_path
+            
+        require 'openssl'
+        require 'webrick/https'
+        
+        cert = OpenSSL::X509::Certificate.new(File.read(cert_path))
+        key = OpenSSL::PKey::RSA.new(File.read(key_path))
+        
+        options[:SSLEnable] = true
+        options[:SSLVerifyClient] = ::OpenSSL::SSL::VERIFY_NONE
+        options[:SSLCertificate] = cert
+        options[:SSLPrivateKey] = key
+      end
+      
+      return handler, options
+    end
+    
+    
+    def prep_mongrel
+      handler = Rack::Handler::Mongrel
+      options = {
+        :Host => @conf.bind_address || "0.0.0.0", 
+        :Port => @conf.port
+      }
+      
+      return handler, options
+    end
+    
+  end
+  
+  class FixContentLength
+    def initialize(app)
+      @app = app
+    end
+  
+    def call(env)
+      status, headers, body = @app.call(env)
+      if headers.has_key?('Content-Length') && headers['Content-Length'].to_i == 0
+        headers['Content-Length'] = body.body.length.to_s
+      end
+      [status, headers, body]
+    end
+  end
+end