Replication Simulator

A module for simulating network conditions when testing replicated data structures.

Usage

const RAM = require('random-access-memory')
const Autobase = require('@holepunchto/autobase-next')
const Hypercore = require('hypercore')
const { Replicator, Network } = require('replication-simulator')

const writer = new Hypercore(RAM.reusable())
await writer.ready()

const reader = new Hypercore(RAM.reusable(), { key: writer.key }),

// returns a replication stream
const replicate = (core, init) => core.replicate(init)

const peers = []
for (const core of [writer, reader]) {
  peers.push(new Replicator(core, { replicate }))
}

const net = new Network(peers)

await writer.append('0')

// ... wait for sync
console.log(reader.length) // 1

await net.down() // stop

await writer.append('1')

// ... wait for sync
console.log(reader.length) // 1

net.up() // resume

// ... wait for sync
console.log(reader.length) // 2

Replicator API

const replicator = new Replicator(object, opts)

Create a new replicator.

const opts = {
  replicate (object, isInitiator) {
    // return a replication stream
  },
  rng () {
    // return a number in range [0, 1)
  }
}

const added = replicator.replicate(remote)

Replicate with the remote, returns false if we are already replicating with remote and true otherwise.

replicator.latency({ read, write })

Simulate connection latency. Bit of a hack, so could be buggy...

await replicator.unreplicate(remote)

Stop replication with remote.

await replicator.drop()

End all replication.

await replicator.flake(interval)

Drop and restart replication at random intervals.

Network API

A network is a set of bases that are all replicating with one another.

const network = new Network(storage, opts)

Create a network.

for (const base of network) {}

Iterate over the bases.

network.size

The number of bases in the network.

network.has(base)

Check if a base is in this network.

network.add(base)

Add a base to the network.

await network.delete(base)

Delete a base from the network.

network.clear()

Clear all peers from the network. Will not end any ongoing replication streams.

network.merge(otherNetwork)

Combine another network into this one.

const [left, right] await network.split(index)

Split a network into 2 at the given index.

netowrk.replicate(base)

Ensure all the peers in the network are replicating with base.

network.unreplicate(base)

All peers in the network will stop replicating with this base.

If base is in the network, it will remain in the network and can be brought up again with network.replicate

network.up()

All peers in the network will stop replicating with each other.

network.down()

All peers in the network will stop replicating with each other.

network.destroy()

End all replication and clear the network.

License

MIT