Cell-based

type Pricer = (plan: string, minutes: number) => number;
const priceV1: Pricer = (plan, minutes) => (plan === "member" ? Math.max(0, minutes - 30) * 10 : 100 + minutes * 10);
const priceV2: Pricer = (plan, minutes) => priceV1(plan, minutes) * 10; // a release with a bug: pence treated as tenths

// A complete copy of Pedal (app, database, queues) serving only its own cities.
class Cell {
  version = "v1"; price: Pricer = priceV1;
  rides: [string, number][] = []; // this cell's own data
  constructor(readonly name: string) {}
  quote(city: string, plan: string, minutes: number): number { const p = this.price(plan, minutes); this.rides.push([city, p]); return p; }
  healthy(): boolean { return this.price("member", 42) === 120; } // a canary check: a known ride must price correctly
}

class Router { // thin: it only maps a city to its cell
  constructor(private cells: Record<string, Cell>, readonly home: Record<string, string>) {}
  quote(city: string, plan: string, minutes: number): number { return this.cells[this.home[city]].quote(city, plan, minutes); }
}

const TRIPS: [string, string, number][] = [["London", "member", 42], ["Paris", "payg", 15], ["Lisbon", "payg", 20], ["Berlin", "member", 42]];
const money = (p: number): string => `${Math.floor(p / 100)}.${String(p % 100).padStart(2, "0")}`;
const run = (r: Router): string => TRIPS.map(([c, plan, m]) => `${c} ${money(r.quote(c, plan, m))}`).join(" | ");

const cells: Record<string, Cell> = { "cell-1": new Cell("cell-1"), "cell-2": new Cell("cell-2"), "cell-3": new Cell("cell-3") };
const router = new Router(cells, { London: "cell-1", Paris: "cell-2", Lisbon: "cell-2", Berlin: "cell-3" });
console.log("all cells on v1: " + run(router));
cells["cell-2"].version = "v2"; cells["cell-2"].price = priceV2; // wave 1: one cell only
console.log("v2 in cell-2: " + run(router));
if (!cells["cell-2"].healthy()) {
  cells["cell-2"].version = "v1"; cells["cell-2"].price = priceV1;
  const affected = Object.entries(router.home).filter(([, h]) => h === "cell-2").map(([c]) => c);
  console.log(`cell-2 failed its health check and rolled back; affected while live: ${affected.length} of 4 cities (${affected.join(", ")})`);
}
router.home.Lisbon = "cell-3"; // rebalance: move a city between cells
console.log("after moving Lisbon to cell-3: " + run(router));
console.log("rides per cell: {" + Object.entries(cells).map(([n, c]) => `'${n}': ${c.rides.length}`).join(", ") + "}");

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.stream.Collectors;

// A complete copy of Pedal (app, database, queues) serving only its own cities.
class Cell {
    final String name; String version = "v1"; BiFunction<String, Integer, Integer> price = Main::priceV1;
    final List<String> rides = new ArrayList<>(); // this cell's own data
    Cell(String name) { this.name = name; }
    int quote(String city, String plan, int minutes) { int p = price.apply(plan, minutes); rides.add(city); return p; }
    boolean healthy() { return price.apply("member", 42) == 120; } // a canary check: a known ride must price correctly
}

class Router { // thin: it only maps a city to its cell
    private final Map<String, Cell> cells; final Map<String, String> home;
    Router(Map<String, Cell> cells, Map<String, String> home) { this.cells = cells; this.home = home; }
    int quote(String city, String plan, int minutes) { return cells.get(home.get(city)).quote(city, plan, minutes); }
}

public class Main {
    static int priceV1(String plan, int minutes) { return plan.equals("member") ? Math.max(0, minutes - 30) * 10 : 100 + minutes * 10; }
    static int priceV2(String plan, int minutes) { return priceV1(plan, minutes) * 10; } // a release with a bug: pence treated as tenths
    static String money(int p) { return (p / 100) + "." + String.format("%02d", p % 100); }
    static final Object[][] TRIPS = {{"London", "member", 42}, {"Paris", "payg", 15}, {"Lisbon", "payg", 20}, {"Berlin", "member", 42}};
    static String run(Router r) {
        List<String> out = new ArrayList<>();
        for (Object[] t : TRIPS) out.add(t[0] + " " + money(r.quote((String) t[0], (String) t[1], (Integer) t[2])));
        return String.join(" | ", out);
    }
    public static void main(String[] args) {
        Map<String, Cell> cells = new LinkedHashMap<>();
        for (String n : List.of("cell-1", "cell-2", "cell-3")) cells.put(n, new Cell(n));
        Map<String, String> home = new LinkedHashMap<>();
        home.put("London", "cell-1"); home.put("Paris", "cell-2"); home.put("Lisbon", "cell-2"); home.put("Berlin", "cell-3");
        Router router = new Router(cells, home);
        System.out.println("all cells on v1: " + run(router));
        cells.get("cell-2").version = "v2"; cells.get("cell-2").price = Main::priceV2; // wave 1: one cell only
        System.out.println("v2 in cell-2: " + run(router));
        if (!cells.get("cell-2").healthy()) {
            cells.get("cell-2").version = "v1"; cells.get("cell-2").price = Main::priceV1;
            List<String> affected = home.entrySet().stream().filter(e -> e.getValue().equals("cell-2")).map(Map.Entry::getKey).collect(Collectors.toList());
            System.out.println("cell-2 failed its health check and rolled back; affected while live: " + affected.size() + " of 4 cities (" + String.join(", ", affected) + ")");
        }
        router.home.put("Lisbon", "cell-3"); // rebalance: move a city between cells
        System.out.println("after moving Lisbon to cell-3: " + run(router));
        System.out.println("rides per cell: {" + cells.entrySet().stream().map(e -> "'" + e.getKey() + "': " + e.getValue().rides.size()).collect(Collectors.joining(", ")) + "}");
    }
}