initial commit

Author: jamescun

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2022 James Cunningham
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,60 @@
+# httplog
+
+httplog is a command line tool that launches a local HTTP server that logs all requests it receives, replying with a canned response.
+
+![screenshot of httplog](extra/screenshot.png)
+
+## Install
+
+Either download a [pre-built binary](https://github.com/jamescun/httplog/releases), or install from source (requires Go 1.19+):
+
+```sh
+go install github.com/jamescun/httplog
+```
+
+
+## Usage
+
+```
+httplog v1.0.0
+
+httplog is a command line tool that launches a local HTTP server that logs all
+requests it receives, replying with a canned response.
+
+Usage: httplog [options...]
+
+Options:
+  --help                        show helpful information
+  --listen         <host:port>  configure the listening address for the HTTP
+                                server (default localhost:8080)
+  --response       <text>       configure the canned body sent in response to
+                                all requests (default none)
+  --response-code  <code>       configure the HTTP status code sent in response
+                                to all requests (default 200)
+  --json                        log all requests as JSON rather than human
+                                readable text
+```
+
+### Examples
+
+Run with no options, a server will be launched on `localhost:8080`, answering no body and an HTTP 200 status code to all requests.
+
+To configure the HTTP status code, use the `--response-code <code>` option, i.e. for a HTTP 500 Internal Server code:
+
+```sh
+$ httplog --response-code 500
+
+$ curl -v http://localhost:8080
+HTTP/1.1 500 Internal Server Error
+```
+
+To configure the response body, use the `--response <text>` option, i.e. to response the text `hello world` to all requests:
+
+```sh
+$ httplog --response "hello world"
+
+$ curl http://localhost:8080
+Hello World
+```
+
+If you would prefer JSON output, rather than human-readable text, use the `--json` option.

extra/screenshot.png

@@ -0,0 +1,3 @@
+module github.com/jamescun/httplog
+
+go 1.19

go.mod

@@ -0,0 +1,37 @@
+package httplog
+
+import (
+	"encoding/json"
+	"io"
+	"text/template"
+)
+
+func JSONLogger(dst io.Writer, reqs <-chan *Request) {
+	for req := range reqs {
+		json.NewEncoder(dst).Encode(req)
+	}
+}
+
+var textBody = template.Must(template.New("").Parse(`
+{{ .At.Format "15:04:05.000" }}:
+Method: {{ .Method }}  Path: {{ .Path }}  Host: {{ .Host }}  Proto: {{ .Proto }}
+{{- if .Query }}
+Query:
+{{- range $header, $values := .Query }}
+  {{ $header }}: {{ range $i, $value := $values }}{{ if $i }},{{ end }}{{ $value }}{{ end -}}
+{{ end }}{{ end }}
+{{- if .Headers }}
+Headers:
+{{- range $header, $values := .Headers }}
+  {{ $header }}: {{ range $i, $value := $values }}{{ if $i }},{{ end }}{{ $value }}{{ end -}}
+{{ end }}{{ end }}
+{{- if .Body }}
+Body:
+  {{ .Body }}{{ end }}
+`))
+
+func TextLogger(dst io.Writer, reqs <-chan *Request) {
+	for req := range reqs {
+		textBody.Execute(dst, req)
+	}
+}

go.sum

@@ -0,0 +1,16 @@
+package httplog
+
+import (
+	"time"
+)
+
+type Request struct {
+	Method  string              `json:"method"`
+	Path    string              `json:"path"`
+	Query   map[string][]string `json:"query,omitempty"`
+	Proto   string              `json:"proto"`
+	Host    string              `json:"host"`
+	Headers map[string][]string `json:"headers,omitempty"`
+	Body    string              `json:"body,omitempty"`
+	At      time.Time           `json:"at"`
+}

httplog/logger.go

@@ -0,0 +1,71 @@
+package httplog
+
+import (
+	"encoding/base64"
+	"io"
+	"mime"
+	"net/http"
+	"time"
+)
+
+type Server struct {
+	// ResponseCode is the HTTP Status Code sent in response to all requests,
+	// if not set, HTTP 200 is used.
+	ResponseCode int
+
+	// ResponseBody is the contents sent in response to all requests, if not
+	// set, no response body is used.
+	ResponseBody []byte
+
+	requests chan *Request
+}
+
+func NewServer(requestBufferSize int) *Server {
+	return &Server{
+		requests: make(chan *Request, requestBufferSize),
+	}
+}
+
+func (s *Server) Requests() <-chan *Request {
+	return s.requests
+}
+
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	req := &Request{
+		Method:  r.Method,
+		Path:    r.URL.Path,
+		Proto:   r.Proto,
+		Headers: r.Header,
+		Host:    r.Host,
+		At:      time.Now(),
+	}
+
+	q := r.URL.Query()
+	if len(q) > 0 {
+		req.Query = q
+	}
+
+	body, _ := io.ReadAll(r.Body)
+	if len(body) > 0 {
+		contentType := r.Header.Get("Content-Type")
+		mediaType, _, _ := mime.ParseMediaType(contentType)
+
+		switch mediaType {
+		case "application/json", "application/x-www-form-urlencoded":
+			req.Body = string(body)
+
+		default:
+			req.Body = base64.StdEncoding.EncodeToString(body)
+		}
+	}
+
+	s.requests <- req
+
+	if s.ResponseCode > 0 {
+		w.WriteHeader(s.ResponseCode)
+	}
+
+	if len(s.ResponseBody) > 0 {
+		w.Write(s.ResponseBody)
+	}
+}

httplog/request.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"net/http"
+	"os"
+
+	"github.com/jamescun/httplog/httplog"
+)
+
+// Version is the semantic release version of this build of httplog.
+var Version = "0.0.0"
+
+var (
+	listenAddr   = flag.String("listen", "localhost:8080", "configure the listening address for the HTTP server")
+	responseBody = flag.String("response", "", "configure the canned body sent in response to all requests")
+	responseCode = flag.Int("response-code", 200, "configure the HTTP status code sent in response requests")
+	logJSON      = flag.Bool("json", false, "log all requests as JSON rather than human readable text")
+)
+
+const Usage = `httplog v%s
+
+httplog is a command line tool that launches a local HTTP server that logs all
+requests it receives, replying with a canned response.
+
+Usage: httplog [options...]
+
+Options:
+  --help                        show helpful information
+  --listen         <host:port>  configure the listening address for the HTTP
+                                server (default localhost:8080)
+  --response       <text>       configure the canned body sent in response to
+                                all requests (default none)
+  --response-code  <code>       configure the HTTP status code sent in response
+                                to all requests (default 200)
+  --json                        log all requests as JSON rather than human
+                                readable text
+`
+
+func main() {
+	flag.Usage = func() { fmt.Fprintf(os.Stderr, Usage, Version) }
+	flag.Parse()
+
+	srv := httplog.NewServer(128)
+
+	srv.ResponseCode = *responseCode
+
+	if *responseBody != "" {
+		srv.ResponseBody = []byte(*responseBody)
+	}
+
+	if *logJSON {
+		go httplog.JSONLogger(os.Stdout, srv.Requests())
+	} else {
+		go httplog.TextLogger(os.Stdout, srv.Requests())
+	}
+
+	s := &http.Server{
+		Addr:    *listenAddr,
+		Handler: srv,
+	}
+
+	fmt.Fprintf(os.Stderr, "server listening on %s...\n", *listenAddr)
+
+	if err := s.ListenAndServe(); err != nil {
+		fmt.Fprintln(os.Stderr, "server error:", err)
+		os.Exit(1)
+	}
+}