more proxy examples

Author: dormando

content/features/proxy/examples.md

@@ -34,6 +34,39 @@ Please see
 [REPLICATE.md](https://github.com/memcached/memcached-proxylibs/blob/main/lib/routelib/REPLICATE.md)
 for more details on what replication means in memcached.
 
+```lua
+pools{
+    -- We create an anonymous set of 3 pools, each with one server.
+    -- This lets us seamlessly expand the total size of the cache by adding
+    -- servers to each pool without changing anything else.
+    set_main = {
+        { backends = { "127.1.0.1:11211" } },
+        { backends = { "127.1.0.2:11211" } },
+        { backends = { "127.1.0.3:11211" } },
+    },
+}
+
+routes{
+    cmap = {
+        -- override specific commands to fetch from just one server for
+        -- performance reasons.
+        get = route_failover{
+            children = "set_main",
+            stats = true, -- get extra stats counters in `stats proxy`
+            miss = true, -- failover if miss, not just for down server
+            shuffle = true, -- each proxy will have a different order
+        },
+        -- if gat/gets/mg/etc are used override here.
+    },
+    -- by default, copy commands to all servers
+    default = route_allfastest{
+        child = "main",
+    },
+}
+```
+
+### Prefix router
+
 ```lua
 -- In this example we logically split our cache where by default keys are
 -- spread across a pool of servers to maximize available memory. Then, a small
@@ -85,3 +118,123 @@ routes{
     },
 }
 ```
+
+### Command map
+
+```lua
+-- if you don't want to route based on prefix, but instead just based on the
+-- command used, replace map with cmap when building routes{}
+pools{
+    foo = {
+        backends = {
+            "127.0.0.1:11214",
+            "127.0.0.1:11215",
+        }
+    },
+    bar = {
+        backends = {
+            "127.0.0.1:11216",
+        }
+    },
+}
+
+routes{
+    cmap = {
+        get = route_direct{
+            child = "foo",
+        },
+    },
+    default = route_allfastest{
+        children = { "bar" }
+    },
+}
+```
+
+### Route by listener port with tags
+
+```lua
+-- it's possible to have different route trees based on the listener port.
+-- this is useful if you want to route to different pools by port alone, or
+-- have different prefix trees for different services.
+--
+-- memcached must be started like:
+-- -l 127.0.0.1:12051 -l tag_b_:127.0.0.1:12052 -l tag_cccc_:127.0.0.1:12053
+-- this gives a default listener on 12051, "b" tag for 12052, and "cccc" tag
+-- for 12053.
+pools{
+    foo = {
+        backends = {
+            "127.0.0.1:11214",
+        }
+    },
+    bar = {
+        backends = {
+            { host = "127.0.0.1", port = 11215, retrytimeout = 5 }
+        }
+    },
+    baz = {
+        backends = {
+            "127.0.0.1:11216",
+        }
+    },
+}
+
+-- no supplied tag makes this the "default" router.
+routes{
+    default = route_direct{
+        child = "foo",
+    }
+}
+
+-- this route tree is only executed if a client is connected to port 12052
+routes{
+    tag = "b",
+    default = route_direct{
+        child = "bar"
+    }
+}
+
+-- this route tree is only executed if a client is connected to port 12053
+routes{
+    tag = "cccc",
+    default = route_direct{
+        child = "baz"
+    }
+}
+```
+
+### Nested route handlers
+
+```lua
+-- A route handler can accept another route handler for any child type entry.
+-- This lets you freely compose complex behaviors from simpler route handlers.
+pools{
+    one = {
+        backends = {
+            "127.0.0.1:11214",
+            "127.0.0.1:11215",
+        }
+    },
+    two = {
+        backends = {
+            "127.0.0.1:11216",
+        }
+    },
+    three = {
+        backends = {
+            "127.0.0.1:11217",
+        }
+    },
+}
+
+routes{
+    map = {
+        foo = route_split{
+            child_a = "foo",
+            child_b = route_allfastest{
+                children = { "two", "three" }
+            },
+        },
+    },
+}
+```