response

README

response

Package response implements an HTTP response writer.

Get started

Install

go get github.com/hslam/response

Import

import "github.com/hslam/response"

Usage

Example

package main

import (
	"bufio"
	"github.com/hslam/mux"
	"github.com/hslam/response"
	"net"
	"net/http"
)

func main() {
	m := mux.New()
	m.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Hello World"))
	})
	ListenAndServe(":8080", m)
}

func ListenAndServe(addr string, handler http.Handler) error {
	ln, err := net.Listen("tcp", addr)
	if err != nil {
		return err
	}
	for {
		conn, err := ln.Accept()
		if err != nil {
			return err
		}
		go func(conn net.Conn) {
			reader := bufio.NewReader(conn)
			rw := bufio.NewReadWriter(reader, bufio.NewWriter(conn))
			var err error
			var req *http.Request
			for {
				req, err = http.ReadRequest(reader)
				if err != nil {
					break
				}
				res := response.NewResponse(req, conn, rw)
				handler.ServeHTTP(res, req)
				res.FinishRequest()
				response.FreeResponse(res)
			}
		}(conn)
	}
}

Netpoll Example

package main

import (
	"bufio"
	"github.com/hslam/mux"
	"github.com/hslam/netpoll"
	"github.com/hslam/response"
	"net"
	"net/http"
	"sync"
)

func main() {
	m := mux.New()
	m.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Hello World"))
	})
	ListenAndServe(":8080", m)
}

func ListenAndServe(addr string, handler http.Handler) error {
	var h = &netpoll.ConnHandler{}
	type Context struct {
		reader  *bufio.Reader
		rw      *bufio.ReadWriter
		conn    net.Conn
		serving sync.Mutex
	}
	h.SetUpgrade(func(conn net.Conn) (netpoll.Context, error) {
		reader := bufio.NewReader(conn)
		rw := bufio.NewReadWriter(reader, bufio.NewWriter(conn))
		return &Context{reader: reader, conn: conn, rw: rw}, nil
	})
	h.SetServe(func(context netpoll.Context) error {
		ctx := context.(*Context)
		ctx.serving.Lock()
		req, err := http.ReadRequest(ctx.reader)
		if err != nil {
			ctx.serving.Unlock()
			return err
		}
		res := response.NewResponse(req, ctx.conn, ctx.rw)
		handler.ServeHTTP(res, req)
		res.FinishRequest()
		ctx.serving.Unlock()
		response.FreeResponse(res)
		return nil
	})
	return netpoll.ListenAndServe("tcp", addr, h)
}

curl -XGET http://localhost:8080

Hello World

License

This package is licensed under a MIT license (Copyright (c) 2020 Meng Huang)

Author

response was written by Meng Huang.

Documentation

Overview

Package response implements an HTTP response writer.

Index

• Constants
• func FreeBufioReader(br *bufio.Reader)
• func FreeBufioWriter(bw *bufio.Writer)
• func FreeResponse(w http.ResponseWriter)
• func NewBufioReader(r io.Reader) *bufio.Reader
• func NewBufioWriter(w io.Writer) *bufio.Writer
• func NewBufioWriterSize(w io.Writer, size int) *bufio.Writer
• type Response
  • func NewResponse(req *http.Request, conn net.Conn, rw *bufio.ReadWriter) *Response
  • func NewResponseSize(req *http.Request, conn net.Conn, rw *bufio.ReadWriter, size int) *Response
  • func (w *Response) FinishRequest()
  • func (w *Response) Flush()
  • func (w *Response) Header() http.Header
  • func (w *Response) Hijack() (net.Conn, *bufio.ReadWriter, error)
  • func (w *Response) Write(data []byte) (n int, err error)
  • func (w *Response) WriteHeader(code int)

Constants

const TimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"

TimeFormat is the time format to use when generating times in HTTP headers. It is like time.RFC1123 but hard-codes GMT as the time zone. The time being formatted must be in UTC for Format to generate the correct format.

For parsing this time format, see ParseTime.

Functions

func FreeBufioReader

func FreeBufioReader(br *bufio.Reader)

FreeBufioReader frees the bufio.Reader.

func FreeBufioWriter

func FreeBufioWriter(bw *bufio.Writer)

FreeBufioWriter frees the bufio.Writer.

func FreeResponse

func FreeResponse(w http.ResponseWriter)

FreeResponse frees the response.

func NewBufioReader

func NewBufioReader(r io.Reader) *bufio.Reader

NewBufioReader returns a new bufio.Reader with r.

func NewBufioWriter

func NewBufioWriter(w io.Writer) *bufio.Writer

NewBufioWriter returns a new bufio.Writer with w.

func NewBufioWriterSize

func NewBufioWriterSize(w io.Writer, size int) *bufio.Writer

NewBufioWriterSize returns a new bufio.Writer with w and size.

Types

type Response

type Response struct {
	// contains filtered or unexported fields
}

Response implements the http.ResponseWriter interface.

func NewResponse

func NewResponse(req *http.Request, conn net.Conn, rw *bufio.ReadWriter) *Response

NewResponse returns a new response.

func NewResponseSize

func NewResponseSize(req *http.Request, conn net.Conn, rw *bufio.ReadWriter, size int) *Response

NewResponseSize returns a new response whose buffer has at least the specified size.

func (*Response) FinishRequest

func (w *Response) FinishRequest()

FinishRequest finishes a request.

func (*Response) Flush

func (w *Response) Flush()

Flush implements the http.Flusher interface.

Flush writes any buffered data to the underlying connection.

func (*Response) Header

func (w *Response) Header() http.Header

Header returns the header map that will be sent by WriteHeader.

func (*Response) Hijack

func (w *Response) Hijack() (net.Conn, *bufio.ReadWriter, error)

Hijack implements the http.Hijacker interface.

Hijack lets the caller take over the connection. After a call to Hijack the HTTP server library will not do anything else with the connection.

func (*Response) Write

func (w *Response) Write(data []byte) (n int, err error)

Write writes the data to the connection as part of an HTTP reply.

func (*Response) WriteHeader

func (w *Response) WriteHeader(code int)

WriteHeader sends an HTTP response header with the provided status code.