changed(moonzero): take base64url from moonbase, and declare the derived impls.

Signed-off-by: Leo Cheng (heke1228) <chengkelfan@qq.com>

Author: Lfan-ke

discov/consul_socket_test.mbt

@@ -17,7 +17,7 @@ fn consul_test_host() -> String {
 ///|
 /// Register `endpoint` for `service` and pass its TTL check so it is healthy at once.
 async fn consul_put_healthy(
-  sock : ConsulSocket,
+  sock : @discov.ConsulSocket,
   service : String,
   id : String,
   host : String,
@@ -36,7 +36,7 @@ async fn consul_put_healthy(
 ///|
 async test "integration: consul discovery register/resolve/deregister over a real consul" {
   guard @env.get_env_var("MOON_CONSUL_TEST") is Some(_) else { return }
-  let sock = ConsulSocket::new(consul_test_host())
+  let sock = @discov.ConsulSocket::new(consul_test_host())
   let id1 = "greeter-10.0.0.1-9090"
   let id2 = "greeter-10.0.0.2-9090"
   // Clean any leftover from a prior run.

discov/discov_test.mbt

@@ -9,14 +9,14 @@ async test "file registry round-trips a real file: reload picks up a persisted i
     let dir = @fs.tmpdir(prefix="mz-reg-rt")
     let path = dir + "/registry.json"
     let writer = @moonzero.PersistentRegistry::new()
-    persist_registry(path, writer)
-    let reader = FileRegistry::load(path)
+    @discov.persist_registry(path, writer)
+    let reader = @discov.FileRegistry::load(path)
     assert_eq(reader.resolve("greet.Greeter").length(), 0)
     let _ = writer.register(
       "greet.Greeter",
       @moonzero.Endpoint::new("10.0.0.7", 9001),
     )
-    persist_registry(path, writer)
+    @discov.persist_registry(path, writer)
     let events = reader.reload()
     assert_eq(events.length(), 1)
     match events[0] {
@@ -41,12 +41,12 @@ async test "file registry reload emits a Delete when an instance leaves" {
       "greet.Greeter",
       @moonzero.Endpoint::new("10.0.0.7", 9001),
     )
-    persist_registry(path, writer)
-    let reader = FileRegistry::load(path)
+    @discov.persist_registry(path, writer)
+    let reader = @discov.FileRegistry::load(path)
     assert_eq(reader.resolve("greet.Greeter").length(), 1)
     let removed = writer.deregister("greet.Greeter", key)
     assert_eq(removed, true)
-    persist_registry(path, writer)
+    @discov.persist_registry(path, writer)
     let events = reader.reload()
     assert_eq(events.length(), 1)
     match events[0] {
@@ -71,8 +71,8 @@ async test "file registry drives a balancer after a real reload" {
       "greet.Greeter",
       @moonzero.Endpoint::new("10.0.0.5", 8443),
     )
-    persist_registry(path, writer)
-    let reader = FileRegistry::load(path)
+    @discov.persist_registry(path, writer)
+    let reader = @discov.FileRegistry::load(path)
     let _ = reader.reload()
     let resolve = reader.resolver()
     match @moonzero.pick_first(resolve("greet.Greeter")) {
@@ -92,8 +92,8 @@ async test "file registry watcher fires on a real file change" {
     let dir = @fs.tmpdir(prefix="mz-watch")
     let path = dir + "/registry.json"
     let writer = @moonzero.PersistentRegistry::new()
-    persist_registry(path, writer)
-    let reader = FileRegistry::load(path)
+    @discov.persist_registry(path, writer)
+    let reader = @discov.FileRegistry::load(path)
     let watcher = @fs.Watcher(dir)
     let holder : Ref[Array[@moonzero.RegistryEvent]] = Ref([])
     let task = g.spawn(() => holder.val = reader.watch_once(watcher))
@@ -102,7 +102,7 @@ async test "file registry watcher fires on a real file change" {
       "greet.Greeter",
       @moonzero.Endpoint::new("10.0.0.9", 9100),
     )
-    persist_registry(path, writer)
+    @discov.persist_registry(path, writer)
     task.wait()
     watcher.close()
     let events = holder.val

discov/etcd_socket.mbt

@@ -144,3 +144,6 @@ pub async fn EtcdSocket::lease_grant(
     self.unary_bytes("/etcdserverpb.Lease/LeaseGrant", req.encode()),
   )
 }
+
+///|
+pub extend EtcdSocket with LeaseKeeper::{forget, renew, grant}

discov/etcd_socket_test.mbt

@@ -18,7 +18,7 @@ fn etcd_test_host() -> String {
 ///|
 /// Grant a lease and Put `endpoint` under `<prefix>/<lease-id>`, returning the lease id.
 async fn etcd_put_instance(
-  sock : EtcdSocket,
+  sock : @discov.EtcdSocket,
   svc_prefix : String,
   endpoint : @moonzero.Endpoint,
 ) -> Int64 {
@@ -34,7 +34,7 @@ async fn etcd_put_instance(
 ///|
 async test "integration: etcd discovery register/resolve/deregister over a real etcd" {
   guard @env.get_env_var("MOON_ETCD_TEST") is Some(_) else { return }
-  let sock = EtcdSocket::connect(etcd_test_host(), 2379)
+  let sock = @discov.EtcdSocket::connect(etcd_test_host(), 2379)
   defer sock.close()
   let svc_prefix = @moonzero.etcd_service_prefix("moonzero-ci/", "greeter")
   let prefix_bytes = @utf8.encode(svc_prefix)
@@ -71,13 +71,13 @@ async test "integration: etcd watch observes a live PUT over a real watch stream
   @async.with_task_group(g => {
     let key = @utf8.encode("moonzero-ci/watch/probe")
     // Clean any leftover on a setup connection.
-    let setup = EtcdSocket::connect(etcd_test_host(), 2379)
+    let setup = @discov.EtcdSocket::connect(etcd_test_host(), 2379)
     let _ = setup.delete_range({ key, range_end: b"", prev_kv: false, })
     setup.close()
     // A concurrent publisher Puts the key once the watch has had time to establish.
     let putter = g.spawn(() => {
       @async.sleep(500)
-      let pub_conn = EtcdSocket::connect(etcd_test_host(), 2379)
+      let pub_conn = @discov.EtcdSocket::connect(etcd_test_host(), 2379)
       let _ = pub_conn.put({
         key,
         value: @utf8.encode("10.0.0.1:9090"),
@@ -86,7 +86,7 @@ async test "integration: etcd watch observes a live PUT over a real watch stream
       pub_conn.close()
     })
     // Watch and read the created ack plus the PUT event the publisher triggers.
-    let sock = EtcdSocket::connect(etcd_test_host(), 2379)
+    let sock = @discov.EtcdSocket::connect(etcd_test_host(), 2379)
     let responses = sock.watch({ key, range_end: b"", start_revision: 0L, }, 2)
     sock.close()
     let _ = putter.wait()
@@ -103,7 +103,7 @@ async test "integration: etcd watch observes a live PUT over a real watch stream
     }
     assert_eq(saw_put, true)
     // Cleanup.
-    let cleanup = EtcdSocket::connect(etcd_test_host(), 2379)
+    let cleanup = @discov.EtcdSocket::connect(etcd_test_host(), 2379)
     let _ = cleanup.delete_range({ key, range_end: b"", prev_kv: false, })
     cleanup.close()
   })

discov/etcd_watch_test.mbt

@@ -1,5 +1,5 @@
 // The etcd Watch stream, driven against a mock etcd Watch RPC over a real socket: the
-// server streams a `created` acknowledgement then a PUT event, and `EtcdSocket::watch` reads
+// server streams a `created` acknowledgement then a PUT event, and `@discov.EtcdSocket::watch` reads
 // and decodes both off the wire. The real-etcd counterpart is gated in the integration test.
 
 ///|
@@ -35,7 +35,7 @@ async test "etcd watch: reads created then a PUT event off a streamed Watch RPC"
     })
     let ts = g.spawn(() => server.serve(port=18140))
     @async.sleep(300)
-    let sock = EtcdSocket::connect("127.0.0.1", 18140)
+    let sock = @discov.EtcdSocket::connect("127.0.0.1", 18140)
     let responses = sock.watch(
       { key: b"svc/", range_end: b"svc0", start_revision: 0L, },
       2,

discov/moon.pkg

@@ -6,7 +6,6 @@ supported_targets = "native"
 
 import {
   "moonbitstack/moonzero",
-  "moonbitstack/moonrpc",
   "moonbitstack/moonrpc/net",
   "moonbitlang/async",
   "moonbitlang/async/fs",

discov/redis_limit_test.mbt

@@ -213,9 +213,9 @@ async test "redis_rate_limit: two assembled apps share one bucket" {
 /// arrangement two replicas have. Gated on `MOON_REDIS_TEST`.
 async test "integration: two period limiters on a live redis share the window" {
   guard @env.get_env_var("MOON_REDIS_TEST") is Some(_) else { return }
-  let s1 = RedisSocket::connect(redis_test_host(), 6379)
+  let s1 = @discov.RedisSocket::connect(redis_test_host(), 6379)
   defer s1.close()
-  let s2 = RedisSocket::connect(redis_test_host(), 6379)
+  let s2 = @discov.RedisSocket::connect(redis_test_host(), 6379)
   defer s2.close()
   let prefix = "moonzero-ci-limit/"
   let key = "period"
@@ -248,9 +248,9 @@ async test "integration: two period limiters on a live redis share the window" {
 /// clock so the refill step is exact. Gated on `MOON_REDIS_TEST`.
 async test "integration: two token limiters on a live redis share the bucket" {
   guard @env.get_env_var("MOON_REDIS_TEST") is Some(_) else { return }
-  let s1 = RedisSocket::connect(redis_test_host(), 6379)
+  let s1 = @discov.RedisSocket::connect(redis_test_host(), 6379)
   defer s1.close()
-  let s2 = RedisSocket::connect(redis_test_host(), 6379)
+  let s2 = @discov.RedisSocket::connect(redis_test_host(), 6379)
   defer s2.close()
   let key = "moonzero-ci-limit/token"
   let _ = s1.command(["DEL", "{" + key + "}.tokens", "{" + key + "}.ts"])

discov/redis_socket_test.mbt

@@ -18,7 +18,10 @@ fn redis_test_host() -> String {
 ///|
 /// SCAN the whole `pattern` keyspace, following the cursor to completion, returning the
 /// matched keys as text.
-async fn scan_all(sock : RedisSocket, pattern : String) -> Array[String] {
+async fn scan_all(
+  sock : @discov.RedisSocket,
+  pattern : String,
+) -> Array[String] {
   let out : Array[String] = []
   let mut cursor = "0"
   let mut first = true
@@ -50,7 +53,7 @@ async fn scan_all(sock : RedisSocket, pattern : String) -> Array[String] {
 
 ///|
 /// Delete every key under `pattern` (idempotent cleanup before a run).
-async fn scan_clean(sock : RedisSocket, pattern : String) -> Unit {
+async fn scan_clean(sock : @discov.RedisSocket, pattern : String) -> Unit {
   let keys = scan_all(sock, pattern)
   if keys.length() > 0 {
     let args = ["DEL"]
@@ -64,7 +67,7 @@ async fn scan_clean(sock : RedisSocket, pattern : String) -> Unit {
 ///|
 async test "integration: RESP discovery register/resolve/deregister over a real redis" {
   guard @env.get_env_var("MOON_REDIS_TEST") is Some(_) else { return }
-  let sock = RedisSocket::connect(redis_test_host(), 6379)
+  let sock = @discov.RedisSocket::connect(redis_test_host(), 6379)
   defer sock.close()
   // Liveness over the real socket.
   assert_eq(sock.command(["PING"]), @moonzero.SimpleString("PONG"))

discovery.mbt

@@ -493,3 +493,9 @@ pub fn LoadBalancedChannel::call_bidi_streaming(
     Err(status) => Err(status)
   }
 }
+
+///|
+pub extend RegistryEvent with Debug::{to_repr}
+
+///|
+pub extend RegistryEvent with Eq::{not_equal, equal}