@@ -23,35 +23,33 @@ end # Parse options opts = OptionParser.new do |opts| - opts.banner = "Usage: camping app1.rb, app2.rb..." - opts.define_head "#{File.basename($0)}, the microframework ON-button for ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]" - opts.separator "" - opts.separator "Specific options:" - - opts.on("-h", "--host HOSTNAME", "Host for web server to bind to (default is all IPs)") { |conf.host| } - opts.on("-p", "--port NUM", "Port for web server (defaults to #{conf.port})") { |conf.port| } - opts.on("-d", "--database FILE", "SQLite3 database path (defaults to #{db_path ? db_path : '<none>'})") { |db_path| conf.database = {:adapter => 'sqlite3', :database => db_path} } - opts.on("-l", "--log FILE", "Start a database log ('-' for STDOUT)") { |conf.log| } - opts.on("-C", "--console", "Run in console mode with IRB") { conf.server = "console" } - server_list = ["mongrel", "webrick", "console"] - opts.on("-s", "--server NAME", server_list, "Server to force (#{server_list.join(', ')})") { |conf.server| } - - opts.separator "" - opts.separator "Common options:" - - # No argument, shows at tail. This will print an options summary. - # Try it and see! - opts.on_tail("-?", "--help", "Show this message") do - puts opts - exit - end - - # Another typical switch to print the version. - opts.on_tail("-v", "--version", "Show version") do - class << Gem; attr_accessor :loaded_specs; end - puts Gem.loaded_specs['camping'].version - exit - end + opts.banner = "Usage: camping app1.rb, app2.rb..." + opts.define_head "#{File.basename($0)}, the microframework ON-button for ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]" + opts.separator "" + opts.separator "Specific options:" + + opts.on("-h", "--host HOSTNAME", "Host for web server to bind to (default is all IPs)") { |conf.host| } + opts.on("-p", "--port NUM", "Port for web server (defaults to #{conf.port})") { |conf.port| } + opts.on("-d", "--database FILE", "SQLite3 database path (defaults to #{db_path ? db_path : '<none>'})") { |db_path| conf.database = {:adapter => 'sqlite3', :database => db_path} } + opts.on("-C", "--console", "Run in console mode with IRB") { conf.server = "console" } + server_list = ["mongrel", "webrick", "console"] + opts.on("-s", "--server NAME", server_list, "Server to force (#{server_list.join(', ')})") { |conf.server| } + + opts.separator "" + opts.separator "Common options:" + + # No argument, shows at tail. This will print an options summary. + # Try it and see! + opts.on_tail("-?", "--help", "Show this message") do + puts opts + exit + end + + # Another typical switch to print the version. + opts.on_tail("-v", "--version", "Show version") do + puts Gem.loaded_specs['camping'].version + exit + end end begin @@ -63,12 +61,12 @@ rescue OptionParser::ParseError => ex end if ARGV.length < 1 - puts opts - exit 1 + puts opts + exit 1 end # Load configuration if any -if rc_path and File.exists?( rc_path ) +if rc_path and File.exists?(rc_path) YAML.load_file(rc_path).each do |k,v| conf.send("#{k}=", v) unless conf.send(k) end @@ -77,7 +75,7 @@ end # Default db if conf.database.nil? and db_path - conf.database = {:adapter => 'sqlite3', :database => db_path} if db_path + conf.database = { :adapter => 'sqlite3', :database => db_path } end @@ -86,14 +84,14 @@ paths = ARGV.dup # Check that mongrel exists if conf.server.nil? || conf.server == "mongrel" - begin - require 'mongrel' - conf.server = "mongrel" - rescue LoadError - puts "!! could not load mongrel. Falling back to webrick." - conf.server = "webrick" - end + begin + require 'mongrel' + conf.server = "mongrel" + rescue LoadError + puts "!! could not load mongrel. Falling back to webrick." + conf.server = "webrick" + end end -server = Camping::Server::Base.new(conf, paths) +server = Camping::Server.new(conf, paths) server.start bin/camping @@ -12,7 +12,7 @@ module Camping # # == Wrapping Your Apps # - # Since bin/camping and the Camping::FastCGI class already use the Reloader, + # Since bin/camping and the Camping::Server class already use the Reloader, # you probably don't need to hack it on your own. But, if you're rolling your # own situation, here's how. # @@ -23,140 +23,160 @@ module Camping # Use this: # # require 'camping/reloader' - # Camping::Reloader.new('/path/to/yourapp.rb') + # reloader = Camping::Reloader.new('/path/to/yourapp.rb') + # blog = reloader.apps[:Blog] + # wiki = reloader.apps[:Wiki] # - # The reloader will take care of requiring the app and monitoring all files - # for alterations. + # The <tt>blog</tt> and <tt>wiki</tt> objects will behave exactly like your + # Blog and Wiki, but they will update themselves if yourapp.rb changes. + # + # You can also give Reloader more than one script. class Reloader - attr_accessor :klass, :mtime, :mount, :requires - - # Creates the reloader, assigns a +script+ to it and initially loads the - # application. Pass in the full path to the script, otherwise the script - # will be loaded relative to the current working directory. - def initialize(script) - @script = File.expand_path(script) - @mount = File.basename(script, '.rb') - @requires = nil - load_app - end - - # Find the application, based on the script name. - def find_app(title) - @klass = Object.const_get(Object.constants.grep(/^#{title}$/i)[0]) rescue nil - end - - # If the file isn't found, if we need to remove the app from the global - # namespace, this will be sure to do so and set @klass to nil. - def remove_app - if @klass - Camping::Apps.delete(@klass) - Object.send :remove_const, @klass.name - @klass = nil - end + attr_reader :scripts + + # This is a simple wrapper which causes the script to reload (if needed) + # on any method call. Then the method call will be forwarded to the + # app. + class App # :nodoc: + instance_methods.each { |m| undef_method m unless m =~ /^__/ } + attr_accessor :app, :script + + def initialize(script) + @script = script + end + + # Reloads if needed, before calling the method on the app. + def method_missing(meth, *args, &blk) + @script.reload! + @app.send(meth, *args, &blk) + end end - - # Loads (or reloads) the application. The reloader will take care of calling - # this for you. You can certainly call it yourself if you feel it's warranted. - def load_app - title = File.basename(@script)[/^([\w_]+)/,1].gsub /_/,'' - begin + + # This class is doing all the hard work; however, it only works on + # single files. Reloader just wraps up support for multiple scripts + # and hides away some methods you normally won't need. + class Script # :nodoc: + attr_reader :apps, :file, :dir, :extras + + def initialize(file) + @file = File.expand_path(file) + @dir = File.dirname(@file) + @extras = File.join(@dir, File.basename(@file, ".rb")) + @mtime = Time.at(0) + @requires = [] + @apps = {} + end + + # Loads the apps availble in this script. Use <tt>apps</tt> to get + # the loaded apps. + def load_apps all_requires = $LOADED_FEATURES.dup - load @script - @requires = ($LOADED_FEATURES - all_requires).select do |req| - req.index(File.basename(@script) + "/") == 0 || req.index(title + "/") == 0 + all_apps = Camping::Apps.dup + + begin + load(@file) + rescue Exception => e + puts "!! Error loading #{@file}:" + puts "#{e.class}: #{e.message}" + puts e.backtrace + puts "!! Error loading #{@file}, see backtrace above" + end + + @requires = ($LOADED_FEATURES - all_requires).map do |req| + full = full_path(req) + full if full == @file or full.index(@extras) == 0 end - rescue Exception => e - puts "!! trouble loading #{title.inspect}: [#{e.class}] #{e.message}" - puts e.backtrace.join("\n") - find_app title - remove_app - return + + @mtime = mtime + + new_apps = (Camping::Apps - all_apps) + old_apps = @apps.dup + @apps = new_apps.inject({}) do |hash, app| + key = app.name.to_sym + hash[key] = old_apps[key] || App.new(self) + hash[key].app = app + hash + end + self end - - @mtime = mtime - find_app title - unless @klass and @klass.const_defined? :C - puts "!! trouble loading #{title.inspect}: not a Camping app, no #{title.capitalize} module found" - remove_app - return + + # Removes all the apps defined in this script. + def remove_apps + @apps.each do |name, app| + Camping::Apps.delete(app.app) + Object.send :remove_const, name + end + end + + # Reloads the file if needed. No harm is done by calling this multiple + # times, so feel free call just to be sure. + def reload! + return if @mtime >= mtime + remove_apps + load_apps + end + + # Checks if both scripts watches the same file. + def ==(other) + @file == other.file + end + + private + + def mtime + (@requires + [@file]).compact.map do |fname| + File.mtime(fname) + end.reject{|t| t > Time.now }.max + end + + # Figures out the full path of a required file. + def full_path(req) + dir = File.expand_path($LOAD_PATH.detect { |l| File.exists?(File.join(l, req)) }) + File.join(dir, req) end - - Reloader.conditional_connect - @klass.create if @klass.respond_to? :create - puts "** #{title.inspect} app loaded" - @klass end - # The timestamp of the most recently modified app dependency. - def mtime - ((@requires || []) + [@script]).map do |fname| - fname = fname.gsub(/^#{Regexp::quote File.dirname(@script)}\//, '') - begin - File.mtime(File.join(File.dirname(@script), fname)) - rescue Errno::ENOENT - remove_app - @mtime - end - end.reject{|t| t > Time.now }.max + # Creates the reloader, assigns a +script+ to it and initially loads the + # application. Pass in the full path to the script, otherwise the script + # will be loaded relative to the current working directory. + def initialize(*scripts) + @scripts = [] + update(*scripts) end - - # Conditional reloading of the app. This gets called on each request and - # only reloads if the modification times on any of the files is updated. - def reload_app - return if @klass and @mtime and mtime <= @mtime - - if @requires - @requires.each { |req| $LOADED_FEATURES.delete(req) } + + # Updates the reloader to only use the scripts provided: + # + # reloader.update("examples/blog.rb", "examples/wiki.rb") + def update(*scripts) + old = @scripts.dup + clear + @scripts = scripts.map do |script| + s = Script.new(script) + if pos = old.index(s) + # We already got a script, so we use the old (which might got a mtime) + old[pos] + else + s.load_apps + end end - remove_app - load_app end - - # Conditionally reloads (using reload_app.) Then passes the request through - # to the wrapped Camping app. - def call(*a) - reload_app - if @klass - @klass.call(*a) - else - Camping.call(*a) - end + + # Removes all the scripts from the reloader. + def clear + @scrips = [] end - - # Returns source code for the main script in the application. - def view_source - File.read(@script) + + # Simply calls reload! on all the Script objects. + def reload! + @scripts.each { |script| script.reload! } end - - class << self - attr_writer :database, :log - - def conditional_connect - # If database models are present, `autoload?` will return nil. - unless Camping::Models.autoload? :Base - if @database and @database[:adapter] == 'sqlite3' - begin - require 'sqlite3_api' - rescue LoadError - puts "!! Your SQLite3 adapter isn't a compiled extension." - abort "!! Please check out http://code.whytheluckystiff.net/camping/wiki/BeAlertWhenOnSqlite3 for tips." - end - end - - case @log - when Logger - Camping::Models::Base.logger = @log - when String - require 'logger' - Camping::Models::Base.logger = Logger.new(@log == "-" ? STDOUT : @log) - end - - Camping::Models::Base.establish_connection @database if @database - - if Camping::Models.const_defined?(:Session) - Camping::Models::Session.create_schema - end - end + + # Returns a Hash of all the apps available in the scripts, where the key + # would be the name of the app (the one you gave to Camping.goes) and the + # value would be the app (wrapped inside App). + def apps + @scripts.inject({}) do |hash, script| + hash.merge(script.apps) end end end lib/camping/reloader.rb @@ -2,61 +2,38 @@ require 'irb' require 'rack' require 'camping/reloader' -module Camping::Server -class Base < Hash - include Enumerable - - attr_reader :paths +class Camping::Server + attr_reader :reloader attr_accessor :conf - - def initialize(conf, paths = []) - unless conf.database - raise "!! No home directory found. Please specify a database file, see --help." - end - + + def initialize(conf, paths) @conf = conf - Camping::Reloader.database = conf.database - Camping::Reloader.log = conf.log - - @paths = [] - paths.each { |script| add_app script } - # TODO exception instead of abort() - # abort("** No apps successfully loaded") unless self.detect { |app| app.klass } - + @paths = paths + @reloader = Camping::Reloader.new + connect(@conf.database) if @conf.database end - - def add_app(path) - @paths << path - if File.directory? path - Dir[File.join(path, '*.rb')].each { |s| insert_app(s)} - else - insert_app(path) + + def connect(db) + unless Camping.autoload?(:Models) + Camping::Models::Base.establish_connection(db) end - # TODO check to see if the application is created or not... exception perhaps? end - def find_new_scripts - self.values.each { |app| app.reload_app } - @paths.each do |path| - Dir[File.join(path, '*.rb')].each do |script| - smount = File.basename(script, '.rb') - next if detect { |x| x.mount == smount } - - puts "** Discovered new #{script}" - # TODO hmm. the next should be handled by the add_app thingy - app = insert_app(script) - next unless app - - yield app - - end + def find_scripts + scripts = @paths.map do |path| + case + when File.file?(path) + path + when File.directory?(path) + Dir[File.join(path, '*.rb')] end - self.values.sort! { |x, y| x.mount <=> y.mount } + end.flatten.compact + @reloader.update(*scripts) end - def index_page - welcome = "You are Camping" - apps = self - <<-HTML + + def index_page(apps) + welcome = "You are Camping" + header = <<-HTML <html> <head> <title>#{welcome}</title> @@ -73,29 +50,66 @@ class Base < Hash </head> <body> <h1>#{welcome}</h1> - <p>Good day. These are the Camping apps you've mounted.</p> - <ul> - #{apps.values.select{|app|app.klass}.map do |app| - "<li><h3 style=\"display: inline\"><a href=\"/#{app.mount}\">#{app.klass.name}</a></h3><small> / <a href=\"/code/#{app.mount}\">View source</a></small></li>" - end.join("\n")} - </ul> - </body> -</html> - HTML + HTML + footer = '</body></html>' + main = if apps.empty? + "<p>Good day. I'm sorry, but I could not find any Camping apps."\ + "You might want to take a look at the console to see if any errors"\ + "have been raised</p>" + else + "<p>Good day. These are the Camping apps you've mounted.</p><ul>" + + apps.map do |mount, app| + "<li><h3 style=\"display: inline\"><a href=\"/#{mount}\">#{app}</a></h3><small> / <a href=\"/code/#{mount}\">View source</a></small></li>" + end.join("\n") + '</ul>' + end + + header + main + footer end - def each(&b) - self.values.each(&b) + def app + reload! + all_apps = apps + rapp = case all_apps.length + when 0 + proc{|env|[200,{'Content-Type'=>'text/html'},index_page([])]} + when 1 + apps.values.first + else + hash = { + "/" => proc {|env|[200,{'Content-Type'=>'text/html'},index_page(all_apps)]} + } + all_apps.each do |mount, wrapp| + # We're doing @reloader.reload! ourself, so we don't need the wrapper. + app = wrapp.app + hash["/#{mount}"] = app + hash["/code/#{mount}"] = proc do |env| + [200,{'Content-Type'=>'text/plain','X-Sendfile'=>wrapp.script.file},''] + end + end + Rack::URLMap.new(hash) + end + rapp = Rack::Lint.new(rapp) + rapp = XSendfile.new(rapp) + rapp = Rack::ShowExceptions.new(rapp) end - - # for RSpec tests + def apps - self.values + @reloader.apps.inject({}) do |h, (mount, wrapp)| + h[mount.to_s.downcase] = wrapp + h + end + end + + def call(env) + app.call(env) end def start handler, conf = case @conf.server when "console" + puts "** Starting console" + this = self + eval("self", TOPLEVEL_BINDING).meta_def(:reload!) { this.reload!; nil } ARGV.clear IRB.start exit @@ -103,56 +117,40 @@ class Base < Hash puts "** Starting Mongrel on #{@conf.host}:#{@conf.port}" [Rack::Handler::Mongrel, {:Port => @conf.port, :Host => @conf.host}] when "webrick" + puts "** Starting WEBrick on #{@conf.host}:#{@conf.port}" [Rack::Handler::WEBrick, {:Port => @conf.port, :BindAddress => @conf.host}] end - rapp = if apps.length > 1 - hash = { - "/" => proc {|env|[200,{'Content-Type'=>'text/html'},index_page]} - } - apps.each do |app| - hash["/#{app.mount}"] = app - hash["/code/#{app.mount}"] = proc do |env| - [200,{'Content-Type'=>'text/plain'},app.view_source] - end - end - Rack::URLMap.new(hash) - else - apps.first - end - rapp = Rack::Lint.new(rapp) - rapp = XSendfile.new(rapp) - rapp = Rack::ShowExceptions.new(rapp) - handler.run(rapp, conf) + handler.run(self, conf) end - private - - def insert_app(script) - self[script] = Camping::Reloader.new(script) + def reload! + find_scripts + @reloader.reload! end -end -# A Rack middleware for reading X-Sendfile. Should only be used in -# development. -class XSendfile + # A Rack middleware for reading X-Sendfile. Should only be used in + # development. + class XSendfile - HEADERS = [ - "X-Sendfile", - "X-Accel-Redirect", - "X-LIGHTTPD-send-file" - ] + HEADERS = [ + "X-Sendfile", + "X-Accel-Redirect", + "X-LIGHTTPD-send-file" + ] - def initialize(app) - @app = app - end + def initialize(app) + @app = app + end - def call(env) - status, headers, body = @app.call(env) - if path = headers.values_at(*HEADERS).compact.first - body = File.read(path) + def call(env) + status, headers, body = @app.call(env) + headers = Utils::HeaderHash.new(headers) + if path = HEADERS.detect { |header| headers.include?(header) } + body = File.read(path) + headers['Content-Length'] = body.length + end + [status, headers, body] end - [status, headers, body] - end -end + end end \ No newline at end of file lib/camping/server.rb 98318d9cc6803d45b006d5ede7aecfa9d2178ea2 Magnus Holm judofyr@gmail.com http://github.com/judofyr/camping/commit/8e78420953370acbe6cfff4d6c9f0e03d8c8e9e3 8e78420953370acbe6cfff4d6c9f0e03d8c8e9e3 2009-02-24T07:49:34-08:00 2009-01-23T12:42:37-08:00 Refactoring of bin/camping, Camping::Server and Camping:Reloader Signed-off-by: why the lucky stiff <why@whytheluckystiff.net> 13c17622174e453a74b571b079c6363b5bb6ecf0 why the lucky stiff why@whytheluckystiff.net