jcarr
/
httppb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: jcarr:master
Branches Tags
jcarr:master
jcarr:devel
jcarr:v0.0.10
jcarr:v0.0.9
jcarr:v0.0.8
jcarr:v0.0.7
jcarr:v0.0.6
jcarr:v0.0.5
jcarr:v0.0.4
jcarr:v0.0.3
jcarr:v0.0.2
jcarr:v0.0.1
..
compare: jcarr:v0.0.2
Branches Tags
jcarr:devel
jcarr:master
jcarr:v0.0.10
jcarr:v0.0.9
jcarr:v0.0.8
jcarr:v0.0.7
jcarr:v0.0.6
jcarr:v0.0.5
jcarr:v0.0.4
jcarr:v0.0.3
jcarr:v0.0.2
jcarr:v0.0.1

No commits in common. "master" and "v0.0.2" have entirely different histories.
master ... v0.0.2

8 changed files with 16 additions and 385 deletions
Show Stats Expand all files Collapse all files

86
httpRequest.dump.go
View File

@ -1,86 +0,0 @@
package httppb
import (
"fmt"
"go.wit.com/log"
)
func (pb *HttpRequest) DumpRemoteAddr() string {
return pb.RemoteAddr
}
func (pb *HttpRequest) DumpUserAgent() string {
var all string
for param, values := range pb.Query {
for _, value := range values {
all += fmt.Sprint(" Query:", param, value)
}
}
// hostname := r.URL.Query().Get("hostname")
return pb.GetUserAgent() + all
}
// todo: convert this code
func (pb *HttpRequest) DumpClient() {
log.Infof("%s %s %s\n", pb.Host, pb.URL, pb.RemoteAddr)
/*
var host, url, proto, addr, agent string
host = r.Host
url = r.URL.String()
proto = r.Proto
addr = r.RemoteAddr
agent = r.UserAgent()
log.Warn(host, proto, addr, url, agent)
fmt.Fprintln(accessf, time.Now(), host, proto, addr, url, agent)
// return
fmt.Fprintln(clientf)
fmt.Fprintln(clientf, time.Now())
// Basic request information
fmt.Fprintln(clientf, "Method:", r.Method)
fmt.Fprintln(clientf, "URL:", r.URL)
fmt.Fprintln(clientf, "Protocol:", r.Proto)
fmt.Fprintln(clientf, "Host:", r.Host)
fmt.Fprintln(clientf, "Remote Address:", r.RemoteAddr)
// Headers
fmt.Fprintln(clientf, "Headers:")
for name, values := range r.Header {
for _, value := range values {
fmt.Fprintln(clientf, "Headers:", name, value)
}
}
// Query parameters
fmt.Fprintln(clientf, "Query Parameters:")
for param, values := range r.URL.Query() {
for _, value := range values {
fmt.Fprintln(clientf, "Query:", param, value)
}
}
// User-Agent
fmt.Fprintln(clientf, "User-Agent:", r.UserAgent())
// Content Length
fmt.Fprintln(clientf, "Content Length:", r.ContentLength)
// Cookies
fmt.Fprintln(clientf, "Cookies:")
for _, cookie := range r.Cookies() {
fmt.Fprintln(clientf, cookie.Name, cookie.Value)
}
// Request Body (if applicable)
if r.Body != nil {
body, err := ioutil.ReadAll(r.Body)
if err == nil {
fmt.Fprintln(clientf, "Body:", string(body))
}
}
*/
}

42
httpRequest.proto
View File

@ -4,34 +4,24 @@ syntax = "proto3";
package httppb;
// todo: try this
// import "google/rpc/status.proto";
// google.rpc.Status error = 13;
import "google/protobuf/timestamp.proto"; // Import the well-known type for Timestamp
message HttpRequest { // HttpRequest represents the essential fields of an incoming HTTP request.
string method = 1; // The request method, e.g., "GET", "POST".
string URL = 2; // The full URL of the request, including scheme, host, path, and query string.
string route = 3; // just the route: "/add/" or "/find/"
string proto = 4; // The protocol version, e.g., "HTTP/1.1", "HTTP/2.0".
map<string, string> headers = 5; // The map of request headers. Header names are case-insensitive,
string IP = 6; // The remote IP address of the client, after resolving proxies.
string host = 7; // The host on which the URL is sought (www.wit.com)
string hostname = 8; // The hostname of the client if passed from the client (mylaptop.fun.me)
string namespace = 9; // This is the pb namespace ("go.wit.com/lib/protobuf/virtpb")
google.protobuf.Timestamp ctime = 10; // create time of the patch
bytes clientData = 11; // the client payload
int64 clientDataLen = 12; // len(body)
bytes serverData = 13; // the server response
int64 serverDataLen = 14; // len(data)
repeated string logs = 15; // use this to store whatever you want while the whole POST happens
string userAgent = 16; // client user-agent
map<string, string> query = 17; // r.URL.Query()
string remoteAddr = 18; // r.RemoteAddr
message HttpRequest { // HttpRequest represents the essential fields of an incoming HTTP request.
string method = 1; // The request method, e.g., "GET", "POST".
string url = 2; // The full URL of the request, including scheme, host, path, and query string.
string route = 3; // just the route: "/add/" or "/find/"
string proto = 4; // The protocol version, e.g., "HTTP/1.1", "HTTP/2.0".
map<string, string> headers = 5; // The map of request headers. Header names are case-insensitive,
string remoteAddr = 6; // The remote IP address of the client, after resolving proxies.
string host = 7; // The host on which the URL is sought (www.wit.com)
string hostname = 8; // The hostname of the client if passed from the client (mylaptop.fun.me)
bytes body = 9; // The request body as raw bytes.
string namespace = 10; // When the body is a pb (always!). This is the pb namespace ("go.wit.com/lib/protobuf/virtpb")
google.protobuf.Timestamp ctime = 11; // create time of the patch
}
message HttpRequests { // `autogenpb:marshal` `autogenpb:mutex`
string uuid = 1; // `autogenpb:uuid:1524ed43-e57d-4bf9-9449-1cdfdc498605`
string version = 2; // `autogenpb:version:v0.0.1`
repeated HttpRequest HttpRequests = 3; // THIS MUST BE HttpRequest and then HttpRequests
message HttpRequests { // `autogenpb:marshal` `autogenpb:mutex`
string uuid = 1; // `autogenpb:uuid:1524ed43-e57d-4bf9-9449-1cdfdc498605`
string version = 2; // `autogenpb:version:v0.0.1`
repeated HttpRequest HttpRequests = 3; // THIS MUST BE HttpRequest and then HttpRequests
}

11
log.go
View File

@ -1,11 +0,0 @@
package httppb
import "fmt"
func (pb *HttpRequest) Log(a ...any) {
pb.Logs = append(pb.Logs, fmt.Sprint(a...))
}
func (pb *HttpRequest) Logf(s string, a ...any) {
pb.Logs = append(pb.Logs, fmt.Sprintf(s, a...))
}

72
middleware.go
View File

@ -1,72 +0,0 @@
package httppb
// http middleware example. probably not interesting since we only pass protobufs
// middleware concepts might, or might not be useful here
/*
// Define a key type to avoid context key collisions.
type contextKey string
const bufferedBodyKey = contextKey("bufferedBody")
// bufferBodyMiddleware reads the request body and replaces it with a new reader,
// allowing it to be read multiple times. The original body is stored in the request context.
func bufferBodyMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Only buffer if there's a body to read.
if r.Body == nil || r.ContentLength == 0 {
next.ServeHTTP(w, r)
return
}
bodyBytes, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Printf("Error reading body in middleware: %v\n", err)
return
}
defer r.Body.Close()
// Store the buffered body in the context for downstream handlers.
ctx := context.WithValue(r.Context(), bufferedBodyKey, bodyBytes)
// Replace the original body with a new reader on the buffered bytes.
// This allows subsequent handlers to read the body again.
r.Body = ioutil.NopCloser(bytes.NewReader(bodyBytes))
// Call the next handler in the chain with the modified request.
next.ServeHTTP(w, r.WithContext(ctx))
})
}
// okHandler is the final handler. It can now safely access the body from the context,
// knowing that other middleware might have also read it.
func okHandler(w http.ResponseWriter, r *http.Request) {
// For demonstration, we can try reading the body directly here too.
// The middleware ensures this is a fresh stream of the buffered data.
bodyFromStream, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Printf("Error reading body in handler: %v", err)
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
return
}
log.Printf("Handler read %d bytes from the request body stream.", len(bodyFromStream))
// We can also retrieve the body from the context if needed.
bodyFromContext, ok := r.Context().Value(bufferedBodyKey).([]byte)
if !ok {
log.Println("Could not retrieve buffered body from context.")
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
return
}
log.Printf("Handler retrieved %d bytes from context.", len(bodyFromContext))
// Prove they are the same.
if !bytes.Equal(bodyFromStream, bodyFromContext) {
log.Println("FATAL: Body from stream and context do not match!")
}
fmt.Fprintf(w, "Successfully read body of %d bytes.\n", len(bodyFromContext))
}
*/

52
post.go
View File

@ -9,59 +9,8 @@ import (
"net/url"
"os"
"os/user"
"go.wit.com/log"
)
// standard protobuf POST
// returns *HttpRequst protobuf
func DoPost(baseURL string, route string, data []byte) (*HttpRequest, error) {
// if you ever have 'http://www.wit.com//' GO will regect the server recieving it.
// Even though the linux kernel gets the network payload
// also it never gives you an error about that, it just goes away invisably inside GO
tmpURL, _ := url.Parse(baseURL) // "http://forge.grid.wit.com:2520")
finalURL := tmpURL.JoinPath(route) // Correctly produces ...:2520/patches
var err error
var req *http.Request
log.Info("httppb.HttpPost to", finalURL.String())
req, err = http.NewRequest(http.MethodPost, finalURL.String(), bytes.NewBuffer(data))
if req == nil {
return nil, err
}
username := os.Getenv("GIT_AUTHOR_NAME")
if username == "" {
usr, _ := user.Current()
username = usr.Username
}
req.Header.Set("author", username)
hostname, _ := os.Hostname()
req.Header.Set("hostname", hostname)
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
reqPB, err := ReqToPB(req)
reqPB.URL = finalURL.String()
reqPB.ClientData = data
reqPB.ClientDataLen = int64(len(data))
reqPB.ServerData = body
reqPB.ServerDataLen = int64(len(body))
return reqPB, nil
}
func HttpPost(baseURL string, route string, data []byte) ([]byte, error) {
// Fix using url.JoinPath (Best Practice)
tmpURL, _ := url.Parse(baseURL) // "http://forge.grid.wit.com:2520")
@ -70,7 +19,6 @@ func HttpPost(baseURL string, route string, data []byte) ([]byte, error) {
var err error
var req *http.Request
log.Info("httppb.HttpPost to", finalURL.String())
req, err = http.NewRequest(http.MethodPost, finalURL.String(), bytes.NewBuffer(data))
if req == nil {
return nil, err

84
reqToPB.go
View File

@ -1,84 +0,0 @@
// Copyright 1994-2025 WIT.COM Inc Licensed GPL 3.0
package httppb
import (
"io/ioutil"
"log"
"net"
"net/http"
"strings"
)
// remove '?' part and trailing '/'
func cleanURL(url string) string {
url = "/" + strings.Trim(url, "/")
return url
}
func getIpSimple(r *http.Request) string {
host, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
log.Printf("could not split host port: %v", err)
return r.RemoteAddr // Fallback
}
return host
}
// getClientIP inspects the request for common headers to find the true client IP.
func getClientIP(r *http.Request) string {
// Caddy sets the X-Forwarded-For header.
if forwardedFor := r.Header.Get("X-Forwarded-For"); forwardedFor != "" {
// The header can be a comma-separated list of IPs. The first one is the original client.
ips := strings.Split(forwardedFor, ",")
return strings.TrimSpace(ips[0])
}
// Fallback to RemoteAddr if the header is not present.
host, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
return r.RemoteAddr
}
return host
}
// converts an *http.Request to an http PB
func ReqToPB(r *http.Request) (*HttpRequest, error) {
// Convert the header map. http.Header is a map[string][]string.
// We'll just take the first value for each header for simplicity.
headers := make(map[string]string)
for name, values := range r.Header {
if len(values) > 0 {
headers[name] = strings.Join(values, "\n")
}
}
query := make(map[string]string)
for param, values := range r.URL.Query() {
if len(values) > 0 {
query[param] = strings.Join(values, "\n")
}
}
msg, err := ioutil.ReadAll(r.Body) // Read the body as []byte
r.Body.Close()
// log.Info("TRYING TO MARSHAL bytes:", len(msg), err)
pb := &HttpRequest{
Method: r.Method,
URL: r.URL.String(),
Proto: r.Proto,
Headers: headers,
IP: getClientIP(r),
Host: r.Host,
ClientData: msg,
ClientDataLen: int64(len(msg)),
Hostname: r.Header.Get("hostname"),
UserAgent: r.UserAgent(),
Query: query,
RemoteAddr: r.RemoteAddr,
}
pb.Route = cleanURL(r.URL.Path)
return pb, err
}

25
startHTTP.go
View File

@ -1,25 +0,0 @@
// Copyright 1994-2025 WIT.COM Inc Licensed GPL 3.0
package httppb
import (
"fmt"
"net/http"
"go.wit.com/log"
)
// starts and sits waiting for HTTP requests
func StartHTTP(okHandler func(http.ResponseWriter, *http.Request), port int) error {
http.HandleFunc("/", okHandler)
p := fmt.Sprintf(":%d", port)
log.Println("Running on port", p)
err := http.ListenAndServe(p, nil)
if err != nil {
log.Println("Error starting server:", err)
return err
}
return nil
}

29
writefile.go
View File

@ -1,29 +0,0 @@
// Copyright 1994-2025 WIT.COM Inc Licensed GPL 3.0
package httppb
import (
"embed"
"fmt"
"net/http"
"go.wit.com/log"
)
func WriteFile(w http.ResponseWriter, resfork embed.FS, filename string) error {
// fmt.Fprintln(w, "GOT TEST?")
fullname := "resources/" + filename
pfile, err := resfork.ReadFile(fullname)
if err != nil {
return err
}
var repohtml string
repohtml = string(pfile)
if filename == "goReference.svg" {
w.Header().Set("Content-Type", "image/svg+xml")
}
fmt.Fprintln(w, repohtml)
log.Println("writeFile() found internal file:", filename)
return nil
}