Client-server and tiers

// Each class below would run on its own machines: a tier. Calls between them would be network calls.

class DataTier { // the database servers
  bikes: Record<string, string[]> = { D12: ["B7", "B9"] };
  rides = new Map<string, { rider: string; bike: string }>();
  takeBike(dock: string): string { return this.bikes[dock].shift() as string; }
  saveRide(id: string, ride: { rider: string; bike: string }): void { this.rides.set(id, ride); }
}

class AppTier { // business rules, behind the web tier
  constructor(private data: DataTier) {}
  unlock(rider: string, dock: string): string {
    const bike = this.data.takeBike(dock);
    const id = `R${this.data.rides.size + 1}`;
    this.data.saveRide(id, { rider, bike });
    return `${id} on ${bike}`;
  }
  price(plan: string, minutes: number): string {
    const p = plan === "member" ? Math.max(0, minutes - 30) * 10 : 100 + minutes * 10;
    return `£${Math.floor(p / 100)}.${String(p % 100).padStart(2, "0")}`;
  }
}

class SessionStore { sessions = new Map<string, { rider: string; plan: string }>(); } // shared by every web server (e.g. Redis)

interface Req { path: string; rider?: string; plan?: string; token?: string; dock?: string; minutes?: number; }

class WebServer { // presentation tier: stateless, many identical copies
  constructor(private name: string, private app: AppTier, private store: SessionStore) {}
  handle(r: Req): string {
    if (r.path === "/login") {
      const token = `s${this.store.sessions.size + 1}`;
      this.store.sessions.set(token, { rider: r.rider ?? "", plan: r.plan ?? "" });
      return `${this.name}: logged in ${r.rider}, session ${token} stored in the shared store`;
    }
    const s = this.store.sessions.get(r.token ?? "");
    if (!s) return `${this.name}: 401 no session`;
    if (r.path === "/unlock") return `${this.name}: session ${r.token} found, unlocked ${this.app.unlock(s.rider, r.dock ?? "")}`;
    return `${this.name}: session ${r.token} found, return after ${r.minutes} min costs ${this.app.price(s.plan, r.minutes ?? 0)}`;
  }
}

const data = new DataTier(), app = new AppTier(data), sessions = new SessionStore();
const servers = [new WebServer("web-1", app, sessions), new WebServer("web-2", app, sessions)];
const requests: Req[] = [{ path: "/login", rider: "Mia", plan: "member" }, { path: "/unlock", token: "s1", dock: "D12" },
  { path: "/return", token: "s1", minutes: 42 }, { path: "/unlock", token: "s9", dock: "D12" }];
requests.forEach((r, i) => console.log(servers[i % servers.length].handle(r))); // round robin
console.log("tiers: client -> web (stateless) -> app -> data");

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;

// Each class below would run on its own machines: a tier. Calls between them would be network calls.
class DataTier { // the database servers
    final Map<String, List<String>> bikes = new HashMap<>(Map.of("D12", new ArrayList<>(List.of("B7", "B9"))));
    final Map<String, String[]> rides = new LinkedHashMap<>();
    String takeBike(String dock) { return bikes.get(dock).remove(0); }
    void saveRide(String id, String rider, String bike) { rides.put(id, new String[]{rider, bike}); }
}

class AppTier { // business rules, behind the web tier
    private final DataTier data;
    AppTier(DataTier data) { this.data = data; }
    String unlock(String rider, String dock) {
        String bike = data.takeBike(dock);
        String id = "R" + (data.rides.size() + 1);
        data.saveRide(id, rider, bike);
        return id + " on " + bike;
    }
    String price(String plan, int minutes) {
        int p = plan.equals("member") ? Math.max(0, minutes - 30) * 10 : 100 + minutes * 10;
        return "£" + (p / 100) + "." + String.format("%02d", p % 100);
    }
}

class SessionStore { final Map<String, String[]> sessions = new HashMap<>(); } // shared by every web server (e.g. Redis)

class WebServer { // presentation tier: stateless, many identical copies
    private final String name; private final AppTier app; private final SessionStore store;
    WebServer(String name, AppTier app, SessionStore store) { this.name = name; this.app = app; this.store = store; }
    String handle(Map<String, String> r) {
        if (r.get("path").equals("/login")) {
            String token = "s" + (store.sessions.size() + 1);
            store.sessions.put(token, new String[]{r.get("rider"), r.get("plan")});
            return name + ": logged in " + r.get("rider") + ", session " + token + " stored in the shared store";
        }
        String[] s = store.sessions.get(r.get("token"));
        if (s == null) return name + ": 401 no session";
        if (r.get("path").equals("/unlock")) return name + ": session " + r.get("token") + " found, unlocked " + app.unlock(s[0], r.get("dock"));
        return name + ": session " + r.get("token") + " found, return after " + r.get("minutes") + " min costs " + app.price(s[1], Integer.parseInt(r.get("minutes")));
    }
}

public class Main {
    public static void main(String[] args) {
        DataTier data = new DataTier();
        AppTier app = new AppTier(data);
        SessionStore sessions = new SessionStore();
        List<WebServer> servers = List.of(new WebServer("web-1", app, sessions), new WebServer("web-2", app, sessions));
        List<Map<String, String>> requests = List.of(Map.of("path", "/login", "rider", "Mia", "plan", "member"), Map.of("path", "/unlock", "token", "s1", "dock", "D12"),
            Map.of("path", "/return", "token", "s1", "minutes", "42"), Map.of("path", "/unlock", "token", "s9", "dock", "D12"));
        for (int i = 0; i < requests.size(); i++) System.out.println(servers.get(i % servers.size()).handle(requests.get(i))); // round robin
        System.out.println("tiers: client -> web (stateless) -> app -> data");
    }
}