# How do i configure this code

**URL:** <https://www.ruby-forum.com/t/how-do-i-configure-this-code/226084>\
**Category:** Ruby\
**Created:** [October 7, 2010, 2:36pm UTC](https://www.ruby-forum.com/t/how-do-i-configure-this-code/226084 "2010-10-07T14:36:36Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![amit-singh](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/a/9f8e36/32.png) [@amit-singh](https://www.ruby-forum.com/u/amit-singh)\
**Post date:** [October 7, 2010, 2:36pm UTC](https://www.ruby-forum.com/t/how-do-i-configure-this-code/226084/1 "2010-10-07T14:36:36Z")

</div>

Hii all ,  
This is code for mongrel http\_request.rb ,here i would like  
to close the Tempfile that was open in following line

@body = Tempfile.new(Const::MONGREL\_TMP\_BASE)  
i tried with @body.close but i have to call at the end of program so as  
there must be noeffect of processing ,means everything being done in  
porogramm

module Mongrel

# 

# When a handler is found for a registered URI then this class is

constructed

# and passed to your HttpHandler::process method. You should assume

that

# _one_ handler processes all requests. Included in the HttpRequest

is a

# HttpRequest.params Hash that matches common CGI params, and a

HttpRequest.body

# which is a string containing the request body (raw for now).

# 

# The HttpRequest.initialize method will convert any request that is

larger than

# Const::MAX\_BODY into a Tempfile and use that as the body. Otherwise

it uses

# a StringIO object. To be safe, you should assume it works like a

file.

# 

# The HttpHandler.request\_notify system is implemented by having

HttpRequest call

# HttpHandler.request\_begins, HttpHandler.request\_progress,

HttpHandler.process during

# the IO processing. This adds a small amount of overhead but lets

you implement

# finer controlled handlers and filters.

# 

class HttpRequest  
attr\_reader :body, :params

```
# You don't really call this. It's made for you.
# Main thing it does is hook up the params, and store any remaining
# body data into the HttpRequest.body attribute.
def initialize(params, socket, dispatchers)
  @params = params
  @socket = socket
  @dispatchers = dispatchers
  content_length = @params[Const::CONTENT_LENGTH].to_i
  remain = content_length - @params.http_body.length

  # tell all dispatchers the request has begun
  @dispatchers.each do |dispatcher|
    dispatcher.request_begins(@params)
  end unless @dispatchers.nil? || @dispatchers.empty?

  # Some clients (like FF1.0) report 0 for body and then send a

```

body. This will probably truncate them but at least the request goes  
through usually.  
if remain \<= 0  
# we’ve got everything, pack it up  
@body = StringIO.new  
@body.write @params.http\_body  
update\_request\_progress(0, content\_length)  
elsif remain \> 0  
# must read more data to complete body  
if remain \> Const::MAX\_BODY  
# huge body, put it in a tempfile

@body = Tempfile.new(Const::MONGREL\_TMP\_BASE)  
@body.binmode

```
    else
      # small body, just use that
      @body = StringIO.new
    end

    @body.write @params.http_body
    read_body(remain, content_length)

  end

  @body.rewind if @body

end

# updates all dispatchers about our progress
def update_request_progress(clen, total)

```

return if @dispatchers.nil? || @dispatchers.empty?  
@dispatchers.each do |dispatcher|  
dispatcher.request\_progress(@params, clen, total)

```
  end
end
private :update_request_progress

# Does the heavy lifting of properly reading the larger body

```

requests in  
# small chunks. It expects @body to be an IO object, @socket to be  
valid,  
# and will set @body = nil if the request fails. It also expects  
any initial  
# part of the body that has been read to be in the @body already.  
def read\_body(remain, total)  
begin  
# write the odd sized chunk first  
@params.http\_body = read\_socket(remain % Const::CHUNK\_SIZE)

```
    remain -= @body.write(@params.http_body)

    update_request_progress(remain, total)

    # then stream out nothing but perfectly sized chunks
    until remain <= 0 or @socket.closed?
      # ASSUME: we are writing to a disk and these writes always

```

write the requested amount  
@params.http\_body = read\_socket(Const::CHUNK\_SIZE)  
remain -= @body.write(@params.http\_body)

```
      update_request_progress(remain, total)

    end

  rescue Object => e
  @body.close

```

@body.delete  
STDERR.puts “#{Time.now}: Error reading HTTP body: #{e.inspect}”  
STDERR.puts e.backtrace.join("\n")  
# any errors means we should delete the file, including if the  
file is dumped  
@socket.close rescue nil

#@body.delete if @body.class == Tempfile  
#@body = nil # signals that there was a problem  
end  
end

```
def read_socket(len)
  if !@socket.closed?
    data = @socket.read(len)

    if !data
      raise "Socket read return nil"
    elsif data.length != len
      raise "Socket read returned insufficient data: #{data.length}"
    else
      data
    end
  else
    raise "Socket already closed when reading."
  end
end

# Performs URI escaping so that you can construct proper
# query strings faster. Use this rather than the cgi.rb
# version since it's faster. (Stolen from Camping).
def self.escape(s)

  s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
    '%'+$1.unpack('H2'*$1.size).join('%').upcase
  }.tr(' ', '+')
end

```

def unlink  
# keep this order for thread safeness  
begin  
File.unlink(@body) if File.exist?(@body)  
@@cleanlist.delete(@body)  
@body = nil  
ObjectSpace.undefine\_finalizer(self)  
rescue Errno::EACCES  
# may not be able to unlink on Windows; just ignore  
end  
end

```
# Unescapes a URI escaped string. (Stolen from Camping).
def self.unescape(s)
  s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
    [$1.delete('%')].pack('H*')
  }
end

# Parses a query string by breaking it up at the '&'
# and ';' characters. You can also use this to parse
# cookies by changing the characters used in the second
# parameter (which defaults to '&;'.
def self.query_parse(qs, d = '&;')
  params = {}
  (qs||'').split(/[#{d}] */n).inject(params) { |h,p|
    k, v=unescape(p).split('=',2)
    if cur = params[k]
      if cur.class == Array
        params[k] << v
      else
        params[k] = [cur, v]
      end
    else
      params[k] = v
    end
  }

  return params
end

```

end

end

#at\_exit { puts “cruel world” }

Thanks all