This lesson's interactive features are locked, please to keep using them

Handler

Now that we've got a lot of the boilerplate stuff out of the way, let's define our handler function. This will allow the users of our server package to define their own logic for handling requests. Here's the function signature we're going to use:

type Handler func(w io.Writer, req *request.Request) *HandlerError

Remember, the official Go stdlib uses this:

type HandlerFunc func(w http.ResponseWriter, r *http.Request)

The main differences between ours and the official one are:

We'll use the more general io.Writer instead of http.ResponseWriter
We'll use our own request.Request type that we just built.
We'll return a *HandlerError. It's just a structured error type that makes it easy to always return a proper status code and error message.

Assignment

Create a Handler function type and HandlerError struct type in your server package. My HandlerError simply contains a status code and a message.
Update server.Serve to accept a Handler function as an argument.
Create some logic that writes a HandlerError to an io.Writer. This will make it easy for us to keep our error handling consistent and DRY.
Update the handle method to:
- Parse the request from the connection
- Create a new empty bytes.Buffer for the handler to write to
- Call the handler function
- If the handler errors, write the error to the connection
- If the handler succeeds:
  - Create new default response headers
  - Write the status line
  - Write the headers
  - Write the response body from the handler's buffer
Back in main, create a handler function. Let's be sure to test our error handling:
- If the request target (path) is /yourproblem return a 400 and the message "Your problem is not my problem\n"
- If the request target (path) is /myproblem return a 500 and the message "Woopsie, my bad\n"
- Otherwise, it should just write the string "All good, frfr\n" to the response body.

Remember, our Handler is responsible for reporting errors or writing the body. Our server implementation takes care of the rest for now.

Run and submit the CLI tests.