From a Script to a Server

package main

import (
	"bufio"
	"fmt"
	"net"
	"net/http"
	"strings"
	"sync/atomic"
)

// The useful work. A script and a server can share exactly the same function.
func countWords(text string) int { return len(strings.Fields(text)) }

// get sends one request by hand and returns the response body.
func get(addr, path string) string {
	conn, err := net.Dial("tcp", addr)
	if err != nil {
		panic(err)
	}
	defer conn.Close()
	fmt.Fprintf(conn, "GET %s HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n", path)
	r := bufio.NewReader(conn)
	for { // skip the status line and headers: they end at the first empty line
		line, err := r.ReadString('\n')
		if line == "\r\n" || err != nil {
			break
		}
	}
	body, _ := r.ReadString(0)
	return body
}

func main() {
	// 1. As a script: get input, do the work once, print, and the program ends.
	fmt.Printf("script: count(%q) = %d, then exit\n", "the quick brown fox", countWords("the quick brown fox"))

	// 2. As a server: a process that stays alive and answers request after request.
	var served atomic.Int64 // state that lives as long as the process does
	mux := http.NewServeMux()
	mux.HandleFunc("/count", func(w http.ResponseWriter, r *http.Request) {
		n := served.Add(1)
		fmt.Fprintf(w, "%d words (request %d since start)", countWords(r.URL.Query().Get("text")), n)
	})
	mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "ok (request %d since start)", served.Add(1))
	})
	ln, err := net.Listen("tcp", "127.0.0.1:0") // port 0: let the OS pick a free port
	if err != nil {
		panic(err)
	}
	srv := &http.Server{Handler: mux}
	go srv.Serve(ln) // the accept loop: wait for a connection, handle it, wait again
	fmt.Println("server: listening on 127.0.0.1 (port chosen by the OS)")

	for _, path := range []string{"/count?text=hello+world", "/count?text=to+be+or+not+to+be", "/health"} {
		fmt.Printf("GET %-32s -> %s\n", path, get(ln.Addr().String(), path))
	}
	srv.Close()
	fmt.Printf("server: shutting down after %d requests\n", served.Load())
}

const http = require("node:http");
const net = require("node:net");

// The useful work. A script and a server can share exactly the same function.
const countWords = (text) => text.split(/\s+/).filter(Boolean).length;

// get sends one request by hand and resolves to the response body.
const get = (port, path) =>
  new Promise((resolve, reject) => {
    const conn = net.connect(port, "127.0.0.1", () =>
      conn.write(`GET ${path} HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n`),
    );
    let reply = "";
    conn.on("data", (d) => (reply += d));
    conn.on("end", () => resolve(reply.split("\r\n\r\n")[1])); // the body starts after the first empty line
    conn.on("error", reject);
  });

// 1. As a script: get input, do the work once, print, and the program ends.
console.log(`script: count("the quick brown fox") = ${countWords("the quick brown fox")}, then exit`);

// 2. As a server: a process that stays alive and answers request after request.
let served = 0; // state that lives as long as the process does
const server = http.createServer((req, res) => {
  const url = new URL(req.url, "http://x");
  served++;
  const body =
    url.pathname === "/count"
      ? `${countWords(url.searchParams.get("text") ?? "")} words (request ${served} since start)`
      : `ok (request ${served} since start)`;
  res.writeHead(200, { "Content-Length": Buffer.byteLength(body) }).end(body);
});

// Port 0: let the OS pick a free port. The event loop then waits for connections.
server.listen(0, "127.0.0.1", async () => {
  console.log("server: listening on 127.0.0.1 (port chosen by the OS)");
  const { port } = server.address();
  for (const path of ["/count?text=hello+world", "/count?text=to+be+or+not+to+be", "/health"]) {
    console.log(`GET ${path.padEnd(32)} -> ${await get(port, path)}`);
  }
  server.close();
  console.log(`server: shutting down after ${served} requests`);
});

use std::io::{BufRead, BufReader, Read, Write};
use std::net::{TcpListener, TcpStream};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;

// The useful work. A script and a server can share exactly the same function.
fn count_words(text: &str) -> usize {
    text.split_whitespace().count()
}

// Answers one connection: read the request line, skip the headers, write a response.
fn handle(conn: TcpStream, served: &AtomicUsize) {
    let mut reader = BufReader::new(&conn);
    let mut line = String::new();
    reader.read_line(&mut line).unwrap();
    let mut header = String::new();
    while reader.read_line(&mut header).unwrap_or(0) > 2 {
        header.clear();
    }
    let n = served.fetch_add(1, Ordering::SeqCst) + 1;
    let target = line.split_whitespace().nth(1).unwrap_or("/");
    let body = match target.split_once("?text=") {
        Some(("/count", text)) => format!("{} words (request {n} since start)", count_words(&text.replace('+', " "))),
        _ => format!("ok (request {n} since start)"),
    };
    let mut out = &conn;
    write!(out, "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len()).unwrap();
}

// Sends one request by hand and returns the response body.
fn get(addr: &str, path: &str) -> String {
    let mut conn = TcpStream::connect(addr).unwrap();
    write!(conn, "GET {path} HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n").unwrap();
    let mut reply = String::new();
    conn.read_to_string(&mut reply).unwrap();
    reply.split_once("\r\n\r\n").unwrap().1.to_string() // the body starts after the first empty line
}

fn main() {
    // 1. As a script: get input, do the work once, print, and the program ends.
    println!("script: count({:?}) = {}, then exit", "the quick brown fox", count_words("the quick brown fox"));

    // 2. As a server: a process that stays alive and answers request after request.
    let served = Arc::new(AtomicUsize::new(0)); // state that lives as long as the process does
    let listener = TcpListener::bind("127.0.0.1:0").unwrap(); // port 0: let the OS pick a free port
    let addr = listener.local_addr().unwrap().to_string();
    let s = served.clone();
    thread::spawn(move || {
        for conn in listener.incoming() {
            handle(conn.unwrap(), &s); // the accept loop: wait for a connection, handle it, wait again
        }
    });
    println!("server: listening on 127.0.0.1 (port chosen by the OS)");

    for path in ["/count?text=hello+world", "/count?text=to+be+or+not+to+be", "/health"] {
        println!("GET {:<32} -> {}", path, get(&addr, path));
    }
    println!("server: shutting down after {} requests", served.load(Ordering::SeqCst));
}

import socket, threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import parse_qs, urlsplit


def count_words(text):
    """The useful work. A script and a server can share exactly the same function."""
    return len(text.split())


def get(port, path):
    """Sends one request by hand and returns the response body."""
    with socket.create_connection(("127.0.0.1", port)) as conn:
        conn.sendall(f"GET {path} HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n".encode())
        reply = b""
        while chunk := conn.recv(4096):
            reply += chunk
    return reply.decode().split("\r\n\r\n", 1)[1]  # the body starts after the first empty line


# 1. As a script: get input, do the work once, print, and the program ends.
print(f'script: count("the quick brown fox") = {count_words("the quick brown fox")}, then exit')

# 2. As a server: a process that stays alive and answers request after request.
served = 0  # state that lives as long as the process does
lock = threading.Lock()


class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        global served
        with lock:
            served += 1
            n = served
        url = urlsplit(self.path)
        if url.path == "/count":
            text = parse_qs(url.query).get("text", [""])[0]
            body = f"{count_words(text)} words (request {n} since start)"
        else:
            body = f"ok (request {n} since start)"
        self.send_response(200)
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body.encode())

    def log_message(self, *args):  # keep the output quiet
        pass


server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)  # port 0: let the OS pick a free port
threading.Thread(target=server.serve_forever, daemon=True).start()  # the accept loop
print("server: listening on 127.0.0.1 (port chosen by the OS)")
for path in ["/count?text=hello+world", "/count?text=to+be+or+not+to+be", "/health"]:
    print(f"GET {path:<32} -> {get(server.server_port, path)}")
server.shutdown()
print(f"server: shutting down after {served} requests")

import com.sun.net.httpserver.HttpServer;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    // The useful work. A script and a server can share exactly the same function.
    static int countWords(String text) {
        return text.isBlank() ? 0 : text.trim().split("\\s+").length;
    }

    // Sends one request by hand and returns the response body.
    static String get(int port, String path) throws Exception {
        try (Socket conn = new Socket("127.0.0.1", port)) {
            conn.getOutputStream().write(("GET " + path + " HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n").getBytes());
            String reply = new String(conn.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
            return reply.split("\r\n\r\n", 2)[1]; // the body starts after the first empty line
        }
    }

    public static void main(String[] args) throws Exception {
        // 1. As a script: get input, do the work once, print, and the program ends.
        System.out.printf("script: count(\"%s\") = %d, then exit%n", "the quick brown fox", countWords("the quick brown fox"));

        // 2. As a server: a process that stays alive and answers request after request.
        AtomicInteger served = new AtomicInteger(); // state that lives as long as the process does
        HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0); // port 0: the OS picks
        server.createContext("/", ex -> {
            int n = served.incrementAndGet();
            String query = ex.getRequestURI().getRawQuery();
            String body = ex.getRequestURI().getPath().equals("/count") && query != null && query.startsWith("text=")
                ? countWords(URLDecoder.decode(query.substring(5), StandardCharsets.UTF_8)) + " words (request " + n + " since start)"
                : "ok (request " + n + " since start)";
            byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
            ex.sendResponseHeaders(200, bytes.length);
            try (OutputStream out = ex.getResponseBody()) { out.write(bytes); }
        });
        server.start(); // the accept loop runs on its own thread from here on
        System.out.println("server: listening on 127.0.0.1 (port chosen by the OS)");

        int port = server.getAddress().getPort();
        for (String path : new String[] {"/count?text=hello+world", "/count?text=to+be+or+not+to+be", "/health"}) {
            System.out.printf("GET %-32s -> %s%n", path, get(port, path));
        }
        server.stop(0);
        System.out.printf("server: shutting down after %d requests%n", served.get());
    }
}