Clarification of the Ruby Socket Library Gets Method

Question

I am working on an assignment where I have to develop a web server in Ruby using the socket library. I was able to get a simple web server up and running as seen in this thread here .

I am currently working on getting and storing the body of an HTTP request into a variable in my web server. The problem I am running into is trying to define a while loop that gets the entire body of a HTTP request.

I am attempting to get the body of a HTTP request by using the gets method. I could not find any documentation on this method (I saw it being used here) and was wondering if there were more documentation online.

In my first post here, someone suggested that I use the Content-Length header to determine the size of the body and how much data to read from the socket. I don't really understand how I would go about implementing this because I am unsure how the gets method functions.

Since this is for an assignment, I don't think posting code would be a good idea. I am looking for more information on the gets method and any tips to point me towards the right direction.

Answer 1

Quite late to the party, but I'm currently implementing my own rack app server (for fun).

Here you can see how I do it: https://github.com/tak1n/reifier/blob/master/lib/reifier/request.rb

The first line of a HTTP request is always the request line, which is basically something like GET /test HTTP/1.1

After the request line until \r\n you get the headers.

After that you are able to read the body (if PUT / POST request) with just using the CONTENT_LENGTH you parsed from the headers.

Answer 2

You shouldn't be using gets. gets tries to read complete lines (ie it reads up to a line separator), but there is no guarantee that an http request body ends with a line separator.

Instead you should be using read - this allows you to read an arbitrary amount of data (as you mentioned you can use the content length header to know how much to read)

Answer 3

Your ultimate problem isn't related to gets, or even really anything in your code. But before we get to that, let's answer this question & explore sockets a little bit.

If you follow the chain up, you find that Ruby's TCPSocket class inherits from its IO class. It's IO that provides gets. gets will read, line-by-line, until there's nothing more to read. Let's create a simple client that connects to a port, spits out 4 lines of poetry, and then quits:

# poetry_sender.rb
require 'socket'

poem = ["'God save thee, ancient Mariner!",
        "From the fiends, that plague thee thus!—",
        "Why look'st thou so?'—With my cross-bow",
        "I shot the ALBATROSS."]

puts "Client establishing connection..."
s = TCPSocket.new 'localhost', 2000

puts "Client sending poetry..."
poem.each { |line| s.puts line } # Print each line out on the socket

s.close # Close our socket
puts "All done."

And a simple server, that displays what the client sends us:

# poetry_receiver.rb
require 'socket'

server = TCPServer.new 2000 # Server bind to port 2000

loop do
  puts "Server now awaiting some poetry..."
  socket = server.accept    # Wait for a client to connect
  while line = socket.gets
    puts "A client sent us this beautiful line: #{line}"
  end
  puts "They had nothing more to say; let's disconnect them."
  socket.close
end

If you run the server (poetry_receiver.rb) first, and then the client, you'll see some output like this:

Server now awaiting a connection...
A client sent us this beautiful line: 'God save thee, ancient Mariner!
A client sent us this beautiful line: From the fiends, that plague thee thus!—
A client sent us this beautiful line: Why look'st thou so?'—With my cross-bow
A client sent us this beautiful line: I shot the ALBATROSS.
They had nothing more to say; let's disconnect them.
Server now awaiting a connection...

The last two lines are the important ones; they indicate that socket.gets returned nil and we exited the while loop.

So, how can we modify our poetry_sender.rb so the server doesn't detect the end of the poem? You might think it's got something to do with blank lines, but if you set poem = [] or poem = ["", "", ""] then you'll find that it still gets disconnected OK. But what if we added a delay before closing the socket in poetry_sender.rb?

sleep 60
s.close # Close our socket
puts "All done."

Now you'll see a big delay in the server output. The TCP server doesn't break out of its while loop until the TCP client closes its socket.

---

Now we can turn to your broader problem: you're trying to implement a simple HTTP server, but your server is getting hung up in a while loop when you try to connect via your web browser. It's because your web browser is keeping that socket open; but it has to, otherwise it has no way to send you back a response. So, how do we know when a client has finished sending us a response? The HTTP 1.1 spec says:

A client sends an HTTP request to a server in the form of a request message... followed by header fields... an empty line to indicate the end of the header section, and finally a message body containing the payload body (if any).

Let's not worry about the message body; how could we write a while loop that terminates if it has no more impact, or if it receives a blank line? Here's one way, in a simple HTTP server that just sends back "Hello world" no matter what request it receives:

require 'socket'

server = TCPServer.new('localhost', 2345)
http_request = [] # We'll store the lines of our incoming request here.

loop do
  socket = server.accept

  while (line = socket.gets) && line.chomp != '' # While the client is connected, and hasn't sent us a blank line yet...
    http_request << line
  end

  # Send response headers
  socket.print "HTTP/1.1 200 OK\r\n" +
               "Content-Type: text/plain\r\n" +
               "Connection: close\r\n" +
               "\r\n"

  # Send response body
  socket.print "Hello world!"
  socket.close
end