# gizlang:mesh

which servers of one service are alive, and which of them owns a key. A node listens on a TCP port and, every interval, exchanges its view with each node it knows (and each seed) in one short connection: it sends its own line and reads the live members of the other node. A member not heard of for holdMs is dead. Ownership is rendezvous hashing: each key goes to the live member with the highest hash of (member, key), so a join or a leave moves only the keys of that member. A mesh belongs to the thread that made it; threads of one process share one node, not one mesh each.

```gizlang
import * as Mesh from "gizlang:mesh";
```

## Types

### `Member`

```gizlang
type Member = { id: string; host: string; port: i64; meta: string; seen: i64; }
```

One node: its name, the address that other nodes connect to, and `meta`, a word without spaces that the node tells the others (for example the port of its service). `seen` is the time (Task.now) it was last heard of.

- `id`: `string`
- `host`: `string`
- `port`: `i64`
- `meta`: `string`
- `seen`: `i64`

### `Mesh`

```gizlang
type Mesh
```

The live view of one node.

- `self`: `gizlang_mesh.Member`
- `holdMs`: `i64`

## Functions

### `join`

```gizlang
function join(sys: System, id: string, host: string, port: i64, meta: string, seeds: Vec<string>, intervalMs: i64, holdMs: i64): Mesh throws IoError
```

Join the mesh as `id`, listening on host:port (0 picks a port; the Mesh says which). `seeds` are "host:port" of nodes to find
the others through. The view refreshes every `intervalMs`; a node silent for `holdMs` is dead (holdMs should be a few intervals).

Effects: fail, read, write, io.

## Methods

### `Mesh.alive`

```gizlang
function Mesh.alive(self: Mesh): Vec<Member>
```

The live members, this node first.

Effects: fail, read, io.

### `Mesh.owner`

```gizlang
function Mesh.owner(self: Mesh, key: string): Member
```

The member that owns `key` (rendezvous hashing over the live members).

Effects: fail, read, io.

### `Mesh.leave`

```gizlang
function Mesh.leave(self: Mesh, sys: System): void
```

Leave: stop answering and probing, and tell each member at once, so the others drop this node now and not after their holdMs.
Stop taking new requests first (close the listener of the service); this does not touch the requests it is answering.

Effects: fail, read, io.