DZone Snippets: webrick code

Basic WEBrick setup for local web server

ntk () — Tue, 17 Jun 2008 17:27:02 GMT

Put the following functions and aliases into your ~/.bash_login (or alternatives).





unset -f webrick_local



function webrick_local() { 



   declare root_dir="${HOME}/Desktop/www"



   /bin/mkdir -p "${root_dir}/WEBrickLog"

   /bin/chmod 0754 "${root_dir}" "${root_dir}/WEBrickLog"



   /usr/bin/touch "${root_dir}/WEBrickLog/webrick.pid" "${root_dir}/WEBrickLog/webrick_ruby.pid"

   /bin/chmod 0644 "${root_dir}/WEBrickLog/webrick.pid" "${root_dir}/WEBrickLog/webrick_ruby.pid"



#   /usr/bin/touch "${root_dir}/index.html"

#   /bin/chmod 0754 "${root_dir}/index.html"





/usr/local/bin/ruby <<-HEREDOC



   require 'webrick'

   require 'webrick/accesslog'

   include WEBrick



   require 'thread'

   require 'pp'



   root_dir = "${root_dir}"

   http_dir = File.expand_path(root_dir)



   File.open(http_dir + "/WEBrickLog/webrick_ruby.pid", "w") do |f|

      f.puts(Process.pid)

   end



   # cf. http://microjet.ath.cx/webrickguide/html/Logging.html

   webrick_log_file = File.expand_path(http_dir + "/WEBrickLog/webrick.log")

   #webrick_log_file = '/dev/null'  # disable logging

   webrick_logger = WEBrick::Log.new(webrick_log_file, WEBrick::Log::DEBUG)



   access_log_stream = webrick_logger

   access_log = [[ access_log_stream, WEBrick::AccessLog::COMBINED_LOG_FORMAT ]]



   system_mime_table = WEBrick::HTTPUtils::load_mime_types('/private/etc/httpd/mime.types.default')

   system_mime_table.store('rhtml', 'text/html')   # add a mime type for .rhtml files

   system_mime_table.store('php', 'text/html')

   system_mime_table.store('rb', 'text/plain')

   system_mime_table.store('pid', 'text/plain')

   #pp system_mime_table.sort_by { |k,v| k }



   server = WEBrick::HTTPServer.new(

     :BindAddress     =>    "localhost",

     :Port            =>    9090,

     :DocumentRoot    =>    http_dir,

     :FancyIndexing   =>    true,

     :MimeTypes       =>    system_mime_table,

     :Logger          =>    webrick_logger,

     :AccessLog       =>    access_log

   )



   server.config.store(:DirectoryIndex, server.config[:DirectoryIndex] << "default.htm")

   #pp server.config



   # cf. http://snippets.dzone.com/posts/show/5208

   class TimeServlet < HTTPServlet::AbstractServlet



      def do_GET(req, res)

         res['Content-Type'] = 'text/html'

         res.status = 200

         res.body = "Time: #{Time.now.to_s}" + "\n"

      end



      # cf. http://www.hiveminds.co.uk/node/244, published under the

      # GNU Free Documentation License, http://www.gnu.org/copyleft/fdl.html



      @@instance = nil

      @@instance_creation_mutex = Mutex.new



      def self.get_instance(config, *options)

         #pp @@instance

         @@instance_creation_mutex.synchronize { 

            @@instance = @@instance || self.new(config, *options) }

      end



   end





   # cf. http://ttripp.blogspot.com/2007/01/fun-with-http.html

   class PostDumper < WEBrick::HTTPServlet::AbstractServlet

  

      # Reload file for each request, instantly

      # updating the server with code changes 

      # without needing a restart.



=begin

      def PostDumper.get_instance( config, *options )

         load __FILE__

         PostDumper.new config, *options

      end

=end



      # cf. http://www.hiveminds.co.uk/node/244, published under the

      # GNU Free Documentation License, http://www.gnu.org/copyleft/fdl.html



      @@instance = nil

      @@instance_creation_mutex = Mutex.new



      def self.get_instance(config, *options)

         #pp @@instance

         @@instance_creation_mutex.synchronize { 

            @@instance = @@instance || self.new(config, *options) }

      end



      def do_GET( request, response )

         response.status = 200

         response['Content-Type'] = "text/plain"

         response.body = dump_request( request )

      end

  

      def do_POST( request, response )

         response.status = 200

         response['Content-Type'] = "text/plain"

         response.body = dump_request( request )

         response.body << request.body

      end

  

      def dump_request( request )

         request.request_line << "\r\n" <<

         request.raw_header.join( "" ) << "\r\n"

      end

   end



   server.mount("/dump", PostDumper)

   server.mount("/time", TimeServlet, {:FancyIndexing=>true})



   # handle signals

   %w(INT).each do |signal|

      trap(signal) { server.shutdown }

   end



   server.start



HEREDOC



return 0



}



export -f webrick_local



# start WEBrick alias

alias webrick='swr'



# start WEBrick

unset -f swr

function swr() {   

  declare webrick_pid_file="${HOME}/Desktop/www/WEBrickLog/webrick.pid"

  if [[ -e "${webrick_pid_file}" ]]; then echo "WEBrick already started!"; return 1; fi

  /bin/bash -c "webrick_local" &

  declare WEBRICKPID=$!

  mkdir -p "${HOME}/Desktop/www/WEBrickLog"

  echo $WEBRICKPID > "${HOME}/Desktop/www/WEBrickLog/webrick.pid"

  return 0

}

export -f swr



# quit WEBrick

unset -f qwr

function qwr() { 

   declare webrick_pid_file="${HOME}/Desktop/www/WEBrickLog/webrick.pid"

   declare webrick_ruby_pid_file="${HOME}/Desktop/www/WEBrickLog/webrick_ruby.pid"

   if [[ ! -e "${webrick_pid_file}" ]]; then echo "no such file: ${webrick_pid_file}"; return 1; fi

   declare PIDW=$(cat "${webrick_pid_file}" 2>/dev/null)

   declare PIDR=$(cat "${webrick_ruby_pid_file}" 2>/dev/null)

   kill -INT $PIDW 2>/dev/null || echo "no such PIDW: ${PIDW}"

   kill -INT $PIDR 2>/dev/null || echo "no such PIDR: ${PIDR}"

   rm -f "${webrick_pid_file}" "${webrick_ruby_pid_file}"

   return 0

}

export -f qwr



# quit WEBrick; cf. Job Control Commands, http://tldp.org/LDP/abs/html/x8816.html

###alias qwr='echo "quit WEBrick with ctrl-c ..."; fg %webrick 2>/dev/null'



alias openwww='/usr/bin/open http://localhost:9090'

alias wrlog='/usr/bin/open http://localhost:9090/WEBrickLog/webrick.log'





#----------------------------------------





source ~/.bash_login



webrick



openwww

wrlog

open http://localhost:9090 

open http://localhost:9090/WEBrickLog

open http://localhost:9090/WEBrickLog/webrick.log



open http://localhost:9090/time

open http://localhost:9090/dump



wrlog

qwr

Further information:

- WEBrick
- WEBrick RDoc
- What is WEBrick?
- Guide to using WEBrick for Rails development
- Dynamic WEBrick Servers in Ruby
- Gnome's Guide to WEBrick
- Running Servlets with WEBrick
- rsphandler
- URL rewriting with WEBrick

Ruby Servlets

jrobertson (James Robertson) — Mon, 10 Mar 2008 23:17:53 GMT

This WEBrick example demonstrates a basic servlet which displays the current time. Source code copied from At the Forge - Getting Started with Ruby [linuxjournal.com].



#!/sw/bin/ruby

require 'webrick'

include WEBrick



# ---------------------------------------------

# Define a new class

class CurrentTimeServlet

  < WEBrick::HTTPServlet::AbstractServlet



  def do_GET(request, response)

    response['Content-Type'] = 'text/plain'

    response.status = 200

    response.body = Time.now.to_s + "\n"

  end

end



# ----------------------------------------------

# Create an HTTP server

s = HTTPServer.new(

  :Port            => 8000,

  :DocumentRoot    => "/usr/local/apache/htdocs/"

)



s.mount("/time", CurrentTimeServlet)



# When the server gets a control-C, kill it

trap("INT"){ s.shutdown }



# Start the server

s.start

e.g. http://localhost:8001/time
output



Mon Mar 10 23:06:58 +0000 2008

Reference: http://www.webrick.org/

Runt.rb

mcandre (Andrew Pennebaker) — Sat, 19 Jan 2008 06:46:42 GMT

// A tiny Ruby web server.



#!/usr/bin/env ruby



require "webrick"



s=WEBrick::HTTPServer.new(

        :BindAddress => "localhost",

        :Port => 8080,

        :DocumentRoot => File.dirname($0)+"/"+"www/"

)



trap("INT") { s.shutdown }



s.start

WEBrick servlet with HTTP authentication

chuyeow (Chu Yeow) — Mon, 16 Apr 2007 15:12:46 GMT

// HTTP authentication for a directory listing



require 'webrick'

include WEBrick



dir = Dir::pwd

port = 1234



authenticate = Proc.new do |req, res|

  HTTPAuth.basic_auth(req, res, '') do |user, password|

    user == 'foo' && password == 'bar'

  end

end



s = HTTPServer.new(:Port => port, :ServerType => Daemon)

s.mount('/', HTTPServlet::FileHandler, dir,

  :FancyIndexing => true,

  :HandlerCallback => authenticate # Hook up the authentication proc.

)



trap('INT') { s.shutdown }

s.start

WEBrick servlet skeleton

chuyeow (Chu Yeow) — Mon, 16 Apr 2007 15:08:46 GMT

// Skeleton code for a WEBrick servlet.



require 'webrick'

include WEBrick

class UberServlet < HTTPServlet::AbstractServlet



  def do_GET(req, res)

    id = req.query['id'] # Get GET/POST params like that.

    res['content-type'] = 'text/html'

    res.status = 200

    res.body = some_text

  end

  alias :do_POST :do_GET



end



# "Mount" the servlet.

server = HTTPServer.new(:Port => 1234)

server.mount('/some/path', UberServlet)



# Handle signals.

%w(INT TERM).each do |signal|

  trap(signal) { server.shutdown }

end



server.start

Stop WeBRICK Server in RadRails (if IDE doesn't)

MattScilipoti (Matt Scilipoti) — Mon, 17 Apr 2006 09:42:51 GMT

From: http://lists.radrails.org/pipermail/radrails/2006-February/000313.html
Just hit Restart and it will actually be started. Then you can stop it. If
all else fails, delete the file



workspace/.metadata/.plugins/org.radrails.server.core/.servers.

Mongrel on Win32 as Service

MattScilipoti (Matt Scilipoti) — Wed, 05 Apr 2006 09:44:32 GMT

Mongrel now has support for running as a Win32 service right out of the box. The support is still rough but works well enough that we decided to release it. You can thank Luis Lavena for working on this and making it so nice.

After you do the gem install, find a Rails application you want to run and do:



$ mongrel_rails_service install -n myapp -r c:\my\path\to\myapp -p 4000 -e production

$ mongrel_rails_service start -n myapp

Now hit the port and poof, works. Stopping the app is just done with:



$ mongrel_rails_service stop -n myapp

And, you can even set the CPU processor affinity for the service when yourun the install command. Can’t even do that on POSIX yet. Now that’s hot.

If you run into an app that’s not running right, my suggestion is to run it with the regular mongrel_rails runner:



$ cd c:\my\path\to\myapp

$ mongrel_rails start -p 4500

Since that will spit out error messages and stuff to the console. Use CTRL-Pause/Break to stop.

Ruby WEBrick as WebDAV Server

MattScilipoti (Matt Scilipoti) — Sun, 12 Mar 2006 07:26:27 GMT

From: http://sg.validcode.at/articles/2006/02/25/vision-everywhere



gem install webrick-webdav

If you have done this dowload webdav.rb.txt rename it to webdav.rb put it into the Vision folder and start it with



ruby PATH/TO/VISION/webdav.rb

Apache2 proxy to local port

brainpipe () — Tue, 31 Jan 2006 11:09:16 GMT

Apache as the receptionist, forwarding requests to and from an internal server (e.g. webrick or lighttpd).





        ServerName www.example.com

        ProxyPass / http://localhost:3000/

        ProxyPassReverse / http://localhost:3000/

        ProxyPreserveHost On

Change 3000 to whatever port you need and make sure the internal server is set up to answer requests on that port (not port 80). The ProxyPreserveHost line is critical to keep all your URLs working correctly.

How to fix a leaky WEBrick

caseygollan (Casey Gollan) — Mon, 25 Apr 2005 05:53:18 GMT

If WEBrick is leaking out of control, which it does do all the time, shut it down and restart it.
Ctrl-c + Up + Enter
WEBrick can slow your computer down to a crawl so it is reccomended that you only use it when it's needed. Otherwise just runs tests, WEBrick's leaks are just another great reason to adapt to test driven development.