Class: HTTPServer

Inherits:

Object

• Object
• HTTPServer

Defined in:

lib/rwd/net.rb

Class Method Summary

• .authenticate(auth, realm, req, resp) ⇒ Object
• .serve(portio = 80, remote = false, auth = nil, realm = "ev/net") ⇒ Object

Class Method Details

.authenticate(auth, realm, req, resp) ⇒ Object

# File 'lib/rwd/net.rb', line 838

def self.authenticate(auth, realm, req, resp)
  if auth.kind_of? String
    file	= "#{home}/#{auth}"
    auths	= {}
    auths	= Hash.file(file)	if File.file?(file)
  else
    auths	= auth
  end

  authuserpassword	= req["authorization"]
  if not authuserpassword.nil?
    authtype, userpassword	= authuserpassword.split(/ /)
    if authtype == "Basic" and not userpassword.nil?
      u, p	= userpassword.unpack("m").shift.split(/:/)
    end
  end

  ok	= (auths.include?(u) and auths[u] == p)

  unless ok
    resp["WWW-Authenticate"]	= "Basic realm=\"#{realm}\""
    resp.response		= "HTTP/1.0 401 Unauthorized"
  end

  req.user	= u

  return ok
end

.serve(portio = 80, remote = false, auth = nil, realm = "ev/net") ⇒ Object

# File 'lib/rwd/net.rb', line 732

def self.serve(portio=80, remote=false, auth=nil, realm="ev/net")
  port, server	= portio

  begin
    server	= TCPServer.new(remote ? "0.0.0.0" : "localhost", port)	if server.nil?

    $stderr.puts "Just point your browser to http://localhost:#{port}/ ..."
  rescue
    server	= nil

    $stderr.puts "Port #{port} is in use."
  end

  if not server.nil?
    count	= 0

    at_exit do
      #$stderr.puts "Received #{count} requests"
    end

    serverthread =
    Thread.new do
      mutex	= Mutex.new

      Thread.current["threads"]	= []

      every(1, Thread.current) do |thread|
        mutex.synchronize do
          thread["threads"].delete_if{|t| (not t.alive?)}
        end
      end

      loop do
        io	= server.accept
        count += 1

        thread =
        Thread.new(Thread.current, count) do |parentthread, count2|
          stop	= false

          begin
            begin
              req	= Request.new(io)
              resp	= Response.new(io)
            rescue
              raise HTTPServerException
            end

            begin
              ip	= req.peeraddr[3]
            rescue NameError
              raise HTTPServerException
            end

            if (not remote) or (remote and (auth.nil? or auth.empty? or authenticate(auth, realm, req, resp)))
          #    $stderr.puts "#{count2} #{Time.new.strftime("%Y-%m-%d %H:%M:%S")} #{ip} #{req.user} #{req.request.to_s.strip}"
           1 == 1
              begin
                yield(req, resp)
              rescue Exception => e
                mutex.synchronize do
                  $stderr.puts e.class.to_s + ": " + e.message
                  $stderr.puts e.backtrace.collect{|s| "\t"+s}.join("\n")
                end
                resp["Content-Type"]	= "text/plain"
                resp.response		= "HTTP/1.0 200 ???"
                resp.clean
                resp << e.class.to_s + ": " + e.message
                resp << "\n"
                resp << "\n"
                resp << e.backtrace.collect{|s| "\t"+s}.join("\n")
                resp << "\n"
                resp << "\n"
                resp << "(You can use the back button and stop the application properly, if appropriate.)"
              end

              stop	= true	if resp.stop?
            end

            begin
              resp.flush			
            rescue
              raise HTTPServerException
            end
          rescue HTTPServerException
          end

          parentthread["stop"]	= resp	if stop
        end

        mutex.synchronize do
          Thread.current["threads"] << thread
        end
      end
    end

    sleep 0.1	while not serverthread["stop"]

    serverthread["threads"].each {|t| t.join}

    serverthread["stop"].at_stop.call

    serverthread.kill
  end
end