iroh 0.25.0 - Custom Protocols For All!

async def custom_protocol_example():
    # setup event loop, to ensure async callbacks work
    iroh.iroh_ffi.uniffi_set_event_loop(asyncio.get_running_loop())

    class MyProtocol:
        async def accept(self, connecting):
            conn = await connecting.connect()
            remote = conn.get_remote_node_id()
            print("accepting from ", remote)
            bi = await conn.accept_bi()
            bytes = await bi.recv().read_to_end(64)
            # prints "got yo":
            print("got", bytes)
            await bi.send().write_all(b"hello")
            await bi.send().finish()
            await bi.send().stopped()

        async def shutdown(self):
            print("shutting down")

    class ProtocolCreator:
        def create(self, endpoint, client):
            return MyProtocol()

    protocols = {}
    protocols[b"example/protocol/0"] = ProtocolCreator()

    options = NodeOptions()
    options.protocols = protocols

    # Create node_0
    node_1 = await Iroh.memory_with_options(options)

    # Create node_1
    node_2 = await Iroh.memory_with_options(options)

    alpn = b"example/protocol/0"
    node_id = await node_1.net().node_id()

    endpoint = node_2.node().endpoint()
    conn = await endpoint.connect_by_node_id(node_id, alpn)
    remote = conn.get_remote_node_id()
    print("", remote)

    bi = await conn.open_bi()

    await bi.send().write_all(b"yo")
    await bi.send().finish()
    await bi.send().stopped()

    out = await bi.recv().read_exact(5)
    # prints "hello":
    print("", out)

    await node_2.node().shutdown(False)
    await node_1.node().shutdown(False)

const alpn = Buffer.from('iroh-example/hello/0')

const protocols = {
  [alpn]: (err, ep, client) => ({
    accept: async (err, connecting) => {
	    if (err != null) {
        throw err
      }
      console.log('accept')
      const nodeId = await client.net.nodeId()
      console.log(`accepting on node ${nodeId}`)
      const alpn = await connecting.alpn()
      console.log(`incoming on ${alpn.toString()}`)

      const conn = await connecting.connect()
      const remote = await conn.getRemoteNodeId()
      console.log(`connected id ${remote.toString()}`)

      const bi = await conn.acceptBi()

      const bytes = await bi.recv.readToEnd(64)
      // prints "got: yo":
      console.log(`got: ${bytes.toString()}`)
      await bi.send.writeAll(Buffer.from('hello'))
      await bi.send.finish()
      await bi.send.stopped()
    },
    shutdown: (err) => {
      if (err != null) {
        throw err
      }
      console.log('shutting down')
    }
  })
}
const node1 = await Iroh.memory({
  protocols,
})

const nodeAddr = await node1.net.nodeAddr()

const node2 = await Iroh.memory({ protocols })
const status = await node2.node.status()
console.log(`status ${status.version}`)
const endpoint = node2.node.endpoint()
console.log(`connecting to ${nodeAddr.nodeId}`)

const conn = await endpoint.connect(nodeAddr, alpn)
const remote = await conn.getRemoteNodeId()
console.log(`connected to ${remote.toString()}`)

const bi = await conn.openBi()

await bi.send.writeAll(Buffer.from('yo'))
await bi.send.finish()
await bi.send.stopped()

let out = Buffer.alloc(5)
await bi.recv.readExact(out)

// prints "read: hello":
console.log(`read: ${out.toString()}`)

await node2.node.shutdown(false)
await node1.node.shutdown(false)

console.log('end')

class MyProtocol : ProtocolHandler {
    override suspend fun accept(connecting: Connecting) {
        val conn = connecting.connect()
        val remote = conn.getRemoteNodeId()
        println("accepting from $remote")
        val bi = conn.acceptBi()

        val bytes = bi.recv().readToEnd(64u)
        val b = bytes.toString(Charsets.UTF_8)
        // prints "got yo":
        println("got $b")
        bi.send().writeAll("hello".toByteArray(Charsets.UTF_8))
        bi.send().finish()
        bi.send().stopped()
    }

    override suspend fun shutdown() {
        println("shutting down")
    }
}

class MyProtocolCreator : ProtocolCreator {
    override fun create(
        endpoint: Endpoint,
        client: Iroh,
    ): MyProtocol = MyProtocol()
}

runBlocking {
    val protocols =
        hashMapOf(
            "example/protocol/0".toByteArray(Charsets.UTF_8)
                to
                MyProtocolCreator(),
        )

    val options = NodeOptions()
    options.protocols = protocols

    // Create node1
    val node1 = Iroh.memoryWithOptions(options)

    // Create node2
    val node2 = Iroh.memoryWithOptions(options)

    val alpn = "example/protocol/0".toByteArray(Charsets.UTF_8)
    val nodeAddr = node1.net().nodeAddr()

    val endpoint = node2.node().endpoint()
    val conn = endpoint.connect(nodeAddr, alpn)
    val remote = conn.getRemoteNodeId()
    println(remote)

    val bi = conn.openBi()

    bi.send().writeAll("yo".toByteArray(Charsets.UTF_8))
    bi.send().finish()
    bi.send().stopped()

    val o = bi.recv().readExact(5u)
    // prints "hello":
    println(o.toString(Charsets.UTF_8))

    node2.node().shutdown(false)
    node1.node().shutdown(false)
}