Module client 

Client protocol implementations

This module contains all client protocol implementations. Each protocol provides LLM-controlled client behavior for connecting to remote servers and exchanging data.

Re-exports

pub use arp::actions::ArpClientProtocol;

pub use bgp::actions::BgpClientProtocol;

pub use bitcoin::actions::BitcoinClientProtocol;

pub use bluetooth::actions::BluetoothClientProtocol;

pub use bootp::actions::BootpClientProtocol;

pub use cassandra::actions::CassandraClientProtocol;

pub use datalink::actions::DataLinkClientProtocol;

pub use dc::actions::DcClientProtocol;

pub use dhcp::actions::DhcpClientProtocol;

pub use dns::actions::DnsClientProtocol;

pub use doh::actions::DohClientProtocol;

pub use dot::actions::DotClientProtocol;

pub use dynamodb::actions::DynamoDbClientProtocol;

pub use elasticsearch::actions::ElasticsearchClientProtocol;

pub use etcd::actions::EtcdClientProtocol;

pub use zookeeper::actions::ZookeeperClientProtocol;

pub use git::actions::GitClientProtocol;

pub use grpc::actions::GrpcClientProtocol;

pub use http::actions::HttpClientProtocol;

pub use http2::actions::Http2ClientProtocol;

pub use http3::actions::Http3ClientProtocol;

pub use http_proxy::actions::HttpProxyClientProtocol;

pub use igmp::actions::IgmpClientProtocol;

pub use imap::actions::ImapClientProtocol;

pub use ipp::actions::IppClientProtocol;

pub use irc::actions::IrcClientProtocol;

pub use isis::actions::IsisClientProtocol;

pub use jsonrpc::actions::JsonRpcClientProtocol;

pub use kafka::actions::KafkaClientProtocol;

pub use kubernetes::actions::KubernetesClientProtocol;

pub use ldap::actions::LdapClientProtocol;

pub use maven::actions::MavenClientProtocol;

pub use mcp::actions::McpClientProtocol;

pub use mdns::actions::MdnsClientProtocol;

pub use mqtt::actions::MqttClientProtocol;

pub use amqp::actions::AmqpClientProtocol;

pub use mysql::actions::MysqlClientProtocol;

pub use mongodb::actions::MongodbClientProtocol;

pub use nfs::actions::NfsClientProtocol;

pub use nfc::NfcClientProtocol;

pub use nntp::actions::NntpClientProtocol;

pub use npm::actions::NpmClientProtocol;

pub use ntp::actions::NtpClientProtocol;

pub use oauth2::actions::OAuth2ClientProtocol;

pub use openai::actions::OpenAiClientProtocol;

pub use ollama::actions::OllamaClientProtocol;

pub use openapi::actions::OpenApiClientProtocol;

pub use openidconnect::actions::OpenIdConnectClientProtocol;

pub use otlp::actions::OtlpClientProtocol;

pub use ospf::actions::OspfClientProtocol;

pub use postgresql::actions::PostgresqlClientProtocol;

pub use pypi::actions::PypiClientProtocol;

pub use mssql::actions::MssqlClientProtocol;

pub use redis::actions::RedisClientProtocol;

pub use icmp::actions::IcmpClientProtocol;

pub use couchdb::actions::CouchDbClientProtocol;

pub use tftp::actions::TftpClientProtocol;

pub use rss::actions::RssClientProtocol;

pub use rip::actions::RipClientProtocol;

pub use s3::actions::S3ClientProtocol;

pub use saml::actions::SamlClientProtocol;

pub use sip::actions::SipClientProtocol;

pub use smb::SmbClientProtocol;

pub use smtp::actions::SmtpClientProtocol;

pub use ftp::actions::FtpClientProtocol;

pub use pop3::actions::Pop3ClientProtocol;

pub use snmp::actions::SnmpClientProtocol;

pub use socks5::actions::Socks5ClientProtocol;

pub use socket_file::SocketFileClientProtocol;

pub use sqs::actions::SqsClientProtocol;

pub use ssh::actions::SshClientProtocol;

pub use ssh_agent::actions::SshAgentClientProtocol;

pub use stun::actions::StunClientProtocol;

pub use syslog::actions::SyslogClientProtocol;

pub use tcp::actions::TcpClientProtocol;

pub use telnet::actions::TelnetClientProtocol;

pub use tls::actions::TlsClientProtocol;

pub use tor::actions::TorClientProtocol;

pub use torrent_dht::actions::TorrentDhtClientProtocol;

pub use torrent_peer::actions::TorrentPeerClientProtocol;

pub use torrent_tracker::actions::TorrentTrackerClientProtocol;

pub use turn::actions::TurnClientProtocol;

pub use udp::actions::UdpClientProtocol;

pub use usb::actions::UsbClientProtocol;

pub use vnc::actions::VncClientProtocol;

pub use webdav::actions::WebdavClientProtocol;

pub use webrtc::actions::WebRtcClientProtocol;

pub use websocket::actions::WebSocketClientProtocol;

pub use whois::actions::WhoisClientProtocol;

pub use stomp::actions::StompClientProtocol;

pub use netbios_ns::actions::NetbiosNsClientProtocol;

pub use nats::actions::NatsClientProtocol;

pub use memcached::actions::MemcachedClientProtocol;

pub use modbus::actions::ModbusClientProtocol;

pub use coap::actions::CoapClientProtocol;

pub use radius::actions::RadiusClientProtocol;

pub use ssdp::actions::SsdpClientProtocol;

pub use gopher::actions::GopherClientProtocol;

pub use finger::actions::FingerClientProtocol;

pub use ident::actions::IdentClientProtocol;

pub use llmnr::actions::LlmnrClientProtocol;

pub use wireguard::actions::WireguardClientProtocol;

pub use xmlrpc::actions::XmlRpcClientProtocol;

pub use xmpp::actions::XmppClientProtocol;

Modules

a2a

A2A 1.0 client over the JSON-RPC binding.

a2s

Steam/Source server query (A2S) client over UDP.

acme

ACME (RFC 8555) client: one account key per client, one current order, an optional http-01 responder, and every request signed and nonce-checked here.

activitypub

ActivityPub client: one actor, served (document, key, inbox) on a local port by the server’s instance code, driven by the handler. Verified inbox activities and the outcome of every action are events.

adc

adc_peer

amqp

AMQP client implementation using lapin library

amqp1

AMQP 1.0 client over the server’s codec: SASL, one session, links per address on demand.

anthropic

Anthropic Messages API client: messages (plain, or server-sent events reassembled into one message), count_tokens and models, one HTTP/1.1 connection per request.

arp

ARP client implementation

aws_support

Credential policy the AWS-SDK clients share. What the AWS-SDK clients (dynamodb, sqs) share about credentials.

bacnet

beanstalkd

bfd

BFD client: one session with one router, in the active role, run by the server’s engine (src/server/bfd/runner.rs). The model is asked when the session starts and whenever its state changes; its answers (timers, AdminDown, back up, disconnect) go to the session, as do actions injected through the client’s command channel.

bgp

BGP client implementation (query mode)

bitcoin

Bitcoin RPC client implementation

bluetooth

Bluetooth Low Energy (BLE) client implementation

bmp

BGP Monitoring Protocol exporter over the collector’s codec: the handler reports peers, routes and statistics; Rust frames BMP and builds the embedded BGP PDUs.

bolt

bootp

BOOTP client implementation

caldav

CalDAV client: the shared DAV client engine in server::dav_common::client with CalDAV’s flavor.

capnp_rpc

Cap’n Proto RPC client: bootstraps the server’s capability, then calls its methods (pipelined, matched by question id) with parameters typed by the startup schema.

carddav

CardDAV client: the shared DAV client engine in server::dav_common::client with CardDAV’s flavor.

cassandra

Cassandra client implementation using ScyllaDB Rust driver

clickhouse

ClickHouse native TCP client at protocol revision 54429. One connection; each action is a query (or an insert) run to its end of stream.

coap

CoAP client: NetGet sends CoAP requests over UDP and the model decides what to ask.

command_support

Generic adoption helpers for the client command channel.

connect_rpc

Typed Connect RPC binding for the shared owned HTTP/1.1 client.

consul

Consul HTTP API client: KV, catalog, health and service registration, one HTTP/1.1 connection per request; KV values come back decoded from base64.

couchdb

CouchDB client implementation

datalink

DataLink client implementation for raw Ethernet frame injection

db2

Db2 client: NetGet speaks DRDA to IBM Db2 or Apache Derby and the model decides what SQL to run. See AGENTS.md beside this file.

dbus

D-Bus client: one connection to a bus (or a peer). Authenticates, says Hello, and then runs three tasks like the other stream clients: a reader, a dispatcher that asks the model about each event in turn, and the session that owns the write half, the serial counter and the calls awaiting replies. A call made to NetGet is answered by the model; one that expects a reply and gets none is answered with an error, as the server does.

dc

DC (Direct Connect) client implementation

dc_peer

devp2p

devp2p dialler. Connects to a node named by its enode URL, runs the RLPx handshake as the initiator and the Hello exchange (the server’s session::establish), then hands the session to a task that asks the model for this node’s Status and carries out its requests.

dhcp

DHCP client implementation

diameter

dicom

DICOM DIMSE service user.

dict

dnp3

dns

DNS client implementation

docker

doh

DNS-over-HTTPS (DoH) client implementation

doq

An authenticated reusable QUIC connection, with independent bounded streams. The registered owner polls all query and handler futures; no detached tasks survive client removal and a parked handler never prevents command injection.

dot

DoT (DNS over TLS) client implementation

dynamodb

DynamoDB client implementation

elasticsearch

Elasticsearch client implementation

epp

EPP registrar client: TLS, the greeting, an optional login, then the handler’s commands.

etcd

etcd client implementation

ethernet_ip

fastcgi

FastCGI 1.0 client in the web-server role.

finger

Finger (RFC 1288) client.

fix

FIX initiator over the acceptor’s codec and session layer.

fluent_forward

One TCP owner; commands stay available while any event handler is parked.

ftp

FTP client implementation

gearman

gelf

GELF UDP/TCP emitter. The command loop owns the only socket and also handles initial actions.

gemini

git

Git client implementation

gnmi

One responsive owner contains calls, subscriptions, event handlers and controls.

gnutella

gopher

Gopher (RFC 1436) client.

graphite

Carbon plaintext TCP emitter. The command loop owns the only socket and also handles initial actions.

graphql

GraphQL over HTTP client.

grpc

gRPC client implementation

grpc_web

Binary gRPC-Web binding for the shared owned HTTP/1.1 client.

gtp

GTP client: the near end of one mobile-core path — an SGSN towards a GGSN (GTPv1 Gn), an SGW towards a PGW (GTPv2 S5/S8) or an MME towards an SGW (GTPv2 S11) — with a GTP-U endpoint for the sessions it creates. See AGENTS.md beside this file.

guacamole

Guacamole client of guacd. connect() runs the handshake (a refusal fails the connect); then a reader task answers sync and acks blobs in Rust and raises the first frame, the remote clipboard and errors; the session task sends the handler’s input.

h323

H.323 client: an endpoint that registers with a gatekeeper and places calls.

hl7

HL7 v2 MLLP sender: one message in flight, its acknowledgment matched on MSA-2.

hls

HLS client (RFC 8216): playlists fetched over HTTP and parsed for the model, segments fetched and analysed (MPEG-TS PAT/PMT, PES timestamps, continuity counters), and whole play runs — a variant chosen, a live playlist reloaded as it slides — summarised in one event. Every URL a playlist names is resolved against it and must stay on the stream’s origin.

http

HTTP client implementation.

http2

HTTP/2 client implementation

http3

Authenticated RFC 9114 client with one owned control driver and bounded request futures. The registered owner polls all query and handler futures; no detached tasks survive client removal and a parked handler never prevents command injection.

http_fetch

The HTTP round trip the HTTP-family clients share: reqwest natively, hyper’s HTTP/1.1 client over the virtual loopback in the browser build. The HTTP round trip the HTTP-family clients share, on both targets.

http_proxy

HTTP proxy client implementation

icap

ICAP client: one request at a time on a persistent connection, preview included.

icmp

ICMP (Internet Control Message Protocol) client implementation

ident

Ident (RFC 1413) client.

iec104

igmp

IGMP client implementation for multicast group management

imap

IMAP client implementation

inetd

Clients for the classic inetd services (RFC 862-868). Each query is one exchange: a fresh TCP connection or one UDP datagram. connect opens nothing, because connecting is itself a request to Daytime, QOTD, Time and Chargen.

influxdb

ipfix

ipp

IPP (Internet Printing Protocol) client implementation

irc

IRC client implementation

isis

IS-IS (Intermediate System to Intermediate System) client implementation

jmap

JMAP client: fetches the session, then sends the handler’s batched requests to its apiUrl.

jsonrpc

JSON-RPC 2.0 client implementation

kafka

Kafka client — pure Rust, no librdkafka.

kerberos

Kerberos V5 client: NetGet gets TGTs and service tickets from a KDC, and the model decides which.

knx

KNXnet/IP tunnelling client: one tunnel to a gateway, group writes and reads out, every group telegram on the bus in as an event.

kubernetes

Kubernetes API client implementation

ldap

LDAP client implementation

libp2p

libp2p client (the dialler): Noise as initiator, yamux, identify and ping, and the application protocols’ streams as events. Shares the server’s stack (server::libp2p).

llm_budget

Per-client LLM call budget.

llmnr

LLMNR (RFC 4795) querier.

lmtp

LMTP (RFC 2033) client: LHLO on connect, then one MAIL/RCPT/DATA transaction per lmtp_send, reading the per-recipient replies LMTP returns after DATA.

loki

lpd

LPD (RFC 1179) client. LPD carries one command per connection, so connect only checks that the server is reachable and every action dials a fresh connection.

lwm2m

LwM2M 1.1 device over the server’s CoAP exchange and content code: registers its object instances, keeps the registration fresh, and answers the server’s requests through the handler.

m3ua

M3UA client: NetGet as an ASP on one association with an SGP (or an IPSP peer), carrying the SS7 upper stack — SCCP, TCAP, MAP and CAMEL — that src/server/m3ua implements.

managesieve

ManageSieve client over the server’s line and literal parser.

matrix

Matrix client (client-server API v3). Logs in with a password, then one task follows /sync and raises what other people did (messages, invites, membership), while the session task performs the handler’s actions, one HTTP/1.1 connection per request.

maven

Maven client implementation

mcp

MCP (Model Context Protocol) client implementation

mdns

mDNS client implementation

media_root

The directory a media client may read local files from (srt, rtmp). The one directory a media client may read a local file from.

memcached

Memcached client: NetGet dials a memcached server and the model drives the text protocol.

milter

Milter client: the MTA side of a mail filter conversation.

minecraft

Minecraft Java Edition client: server-list pings (modern and legacy) and login probes, each over a fresh TCP connection, as a launcher’s server list does.

modbus

Modbus/TCP client: NetGet is the master, the model decides what to read and write.

mongodb

MongoDB client implementation

mqtt

MQTT client implementation, over rumqttc’s 3.1.1 and 5.0 stacks.

mqtt_sn

MQTT-SN 1.2 sensor client over the gateway’s codec: one outstanding operation at a time, retried, with deliveries from the gateway acknowledged and reported as they arrive.

msgpack_rpc

MessagePack-RPC client: one connection, pipelined calls matched by msgid, notifications in both directions.

mssql

MSSQL client implementation using tiberius

mysql

MySQL client implementation

nats

NATS client: NetGet joins a real messaging fabric as a peer.

nbd

Network Block Device client: fixed newstyle negotiation, then one request at a time.

netbios_ns

NetBIOS Name Service client (RFC 1001 / RFC 1002) — the nbtstat equivalent.

netconf

NETCONF client over SSH: pinned host key, password auth, the netconf subsystem, and one correlated RPC at a time.

netflow_v9

nfc

NFC (Near Field Communication) client implementation

nfs

NFS client implementation

ngap

NGAP client: NetGet as a gNB on one N2 association with one AMF.

ninep

9P2000 client. One connection, attached once; each action walks from the root fid to a fresh fid, does its work and clunks it.

nntp

Sequential, bounded NNTP transactions over TCP or verified implicit TLS.

nostr

npm

NPM Registry client implementation

nsq

ntp

NTP client implementation

nut

oauth2

OAuth2 client implementation

oci_registry

ocpp

Simulated OCPP-J charge point: one outstanding CALL each way, ids correlated by Rust.

ollama

Ollama client implementation

onvif

ONVIF client: SOAP 1.2 requests to a device’s Device and Media services, each signed with a WS-Security PasswordDigest UsernameToken whose Created follows the device’s clock.

opcua

openai

OpenAI client implementation

openapi

OpenAPI client implementation - spec-driven HTTP requests

openidconnect

OpenID Connect client implementation

ospf

OSPF client implementation - Query mode for topology discovery

otlp

Reusable OTLP connections with owned exports, response handlers and socket shutdown.

pfcp

PFCP client: the control-plane side (an SMF) of one N4 association with one UPF.

pop3

postgresql

PostgreSQL client implementation

prometheus

prometheus_remote_write

pulsar

Apache Pulsar client: one connection to a broker, producers and consumers created on demand (each after a lookup), messages handed to the handler and acknowledged after it.

pypi

PyPI (Python Package Index) client implementation

quic

An authenticated reusable QUIC connection, with independent bounded streams. The registered owner polls all query and handler futures; no detached tasks survive client removal and a parked handler never prevents command injection.

radius

RADIUS client (a NAS): NetGet authenticates users and reports accounting to a RADIUS server, and the model decides who and what.

radsec

RadSec client (RFC 6614): the RADIUS client’s transport and turns over one TLS connection.

rcon

Source/Minecraft RCON client: login on connect, then one EXECCOMMAND per action, with the output of a Source server collected up to the mirrored empty-packet sentinel.

rdap

RDAP client: one structured query at a time against a fixed base URL.

rdp

RDP client. IronRDP runs the connection sequence (X.224 negotiation, TLS, CredSSP for NLA, MCS/GCC, licensing, capabilities, finalization) and decodes the server’s graphics into a framebuffer. The model’s actions become fast-path input; rdp_read_screen describes the framebuffer as colours once the server has stopped drawing.

redfish

DMTF Redfish client.

redis

Redis client implementation

response_reader

Bounded framing for text responses from remote servers.

restconf

RESTCONF client over the shared HTTP fetch client.

rip

RIP (Routing Information Protocol) client implementation

rpki_rtr

RPKI-to-Router client in the router role. Rust sends the Reset Query on connect, polls with Serial Queries at the refresh interval and on Serial Notify, and answers Cache Reset with a new Reset Query; the handler hears about each completed exchange.

rss

RSS (Really Simple Syndication) Feed Client

rsync

rsync client: each model action is one connection to the daemon (rsync opens a connection per transfer too) — the @RSYNCD handshake, the arguments, the file list, the requests and the end-of-run exchange, at protocol 29 (src/server/rsync/wire.rs).

rtmp

RTMP client over the server’s handshake, chunk and AMF0 code.

rtp

RTP endpoint (client role): sends synthesized G.711 to remote_addr in paced 20 ms frames, receives on listen, and summarises what arrives per SSRC — one event when a stream starts, one when it ends — rather than per packet, which at 50 packets a second would be a model call every 20 ms.

rtsp

RTSP client: one control connection to a media server, requests made on the handler’s say, UDP RTP/RTCP port pairs bound per SETUP, and the media that arrives summarised per stream by the RTP client’s tracker.

s3

S3 client implementation

s7comm

saml

SAML client implementation

scim

SCIM 2.0 client.

sflow

sip

SIP client implementation

smb

SMB client implementation

smpp

SMPP 3.4 ESME client: one bound session; submits are pipelined and matched to their responses by sequence number; deliver_sm (messages and receipts) is acknowledged in Rust.

smtp

SMTP client implementation using lettre library

snmp

SNMP client implementation

snowflake

Snowflake client: NetGet speaks Snowflake’s connector REST protocol and the model decides what SQL to run. See AGENTS.md beside this file.

socket_file

Socket File client implementation

socketio

Socket.IO v5 client over Engine.IO v4 (direct WebSocket or HTTP long-polling).

socks5

SOCKS5 client implementation

soulseek

soulseek_peer

spark

Spark client: NetGet reads Apache Spark’s monitoring REST API (/api/v1, served by a live driver’s UI and by the History Server) and the model decides what to read. See AGENTS.md beside this file.

spice

SPICE client. Links the main channel with the password’s RSA-OAEP ticket, learns the session id from SPICE_MSG_MAIN_INIT, asks for the channel list, then links the display and inputs channels into the same session. The display channel is decoded into a picture of the primary surface (display.rs); the model’s actions become scancodes and mouse messages on the inputs channel; spice_read_screen describes the picture once the server stops drawing.

sqs

SQS client implementation

srt

SRT caller over srt-tokio.

ssdp

SSDP / UPnP discovery client — socket loop.

sse

Server-sent events client: an HTTP/1.1 GET held open, its body parsed as an event stream, and EventSource’s reconnects — the server’s retry hint, Last-Event-ID, no reconnect after a refusal. Each event goes to the handler, which may reconnect or stop.

ssh

SSH commands and bounded SFTP v3 operations on one authenticated owned session.

ssh_agent

SSH Agent client implementation

statsd

StatsD emitter. The command loop owns the only socket and also handles initial actions.

stomp

STOMP 1.2 client implementation.

stratum

Stratum V1 miner (client role): subscribes and authorizes on connect, tracks the pool’s work and difficulty, and mines and submits as the handler directs. Shares are built and hashed with the same code the pool role verifies them with.

stratum_v2

Stratum V2 mining device (client role): the Noise NX handshake with the pool’s certificate checked against its authority key, SetupConnection, a channel opened on connect, the pool’s work tracked, and shares mined and submitted as the handler directs. Shares are built and hashed with the same code the pool role verifies them with.

stun

STUN client implementation for NAT traversal discovery

sunrpc

ONC RPC portmapper/rpcbind client: one TCP connection, one call at a time, each reply matched by xid and raised to the handler as sunrpc_reply.

syslog

Syslog client implementation

tacacs

tcp

TCP client implementation

telnet

Telnet client implementation with option negotiation

tftp

TFTP (RFC 1350) client implementation

thrift

Apache Thrift RPC client over the server’s IDL parser and codecs.

tls

TLS client implementation

tor

Tor client implementation using arti

torrent_dht

BitTorrent DHT client implementation

torrent_peer

BitTorrent Peer Wire Protocol client implementation

torrent_tracker

BitTorrent Tracker client implementation

tr069

TR-069 device (client role). A session is a run of HTTP POSTs to the ACS: Inform, then whatever the ACS answers — an RPC the handler answers in the next POST, or 204 to end it. A connection-request listener lets the ACS ask for a session.

turn

TURN client implementation

udp

UDP client implementation

usb

USB client implementation

vault

vnc

VNC (Remote Framebuffer) client implementation

vxlan

VXLAN / Geneve / GRE (gretap, in UDP) client: one host on the overlay, behind a tunnel to one remote tunnel endpoint. ARP and echo requests for its own IP are answered in Rust, as any host’s stack would; what the model asks for (resolve, ping, UDP) waits on ARP when the MAC is not yet known, and what comes back is reported as events.

wamp

WAMP v2 client, JSON over WebSocket, in all four roles.

webdav

WebDAV client implementation

webrtc

WebRTC client implementation (data channels only, no media)

websocket

WebSocket (RFC 6455) client.

webtransport

WebTransport client: opens one session over the vendored wtransport and runs the server’s Session loop on it, with handler turns going through call_llm_for_client.

whois

WHOIS client implementation.

wire_values

Checked conversion of JSON action values to protocol fields.

wireguard

WireGuard VPN client implementation

wsdiscovery

WS-Discovery client: probes from an ephemeral UDP port (to the multicast group, or to remote_addr for a directed probe) and collects every answer whose RelatesTo names the probe until its wait ends, then reports them once. Optionally hears Hello and Bye on 3702.

x11

X11 client: one connection to an X server (TCP or a Unix socket). The model creates and manages windows and reads and writes properties; each action is executed whole — interning the atoms it needs, sending its requests, then a GetInputFocus round trip that proves the server has processed them — and answered with one x11_result or x11_error.

xmlrpc

XML-RPC client implementation

xmpp

XMPP (Jabber) client implementation

yarn

YARN client: NetGet reads a Hadoop YARN ResourceManager’s REST API (/ws/v1/cluster) and the model decides what to read. See AGENTS.md beside this file.

zabbix

Zabbix client: passive checks against agents and sender data to trappers, one ZBXD request per connection, framed with the trapper server’s own wire module.

zenoh

Zenoh client or peer over the zenoh runtime, sharing the server’s node code.

zeromq

ZeroMQ client socket (REQ, DEALER, PUSH or SUB) over ZMTP 3.1 with the NULL mechanism.

zipkin

Zipkin reporter: reports spans to a collector and queries its read API, one HTTP/1.1 connection per request.

zookeeper

ZooKeeper client implementation