Overlay (Pastry)
Purpose
The overlay provides the structured peer-to-peer substrate the whole LibreSocial framework sits on: a 160-bit identifier space with proximity-aware DHT routing, node identity derived from the user's elliptic-curve public key, join/bootstrapping with per-ring membership, and the transport plumbing that carries messaging, PAST storage, SCRIBE and monitoring traffic. The code contains
Source/rice.freepastry/— a vendored, modified fork of FreePastry (Rice/MPI-SWS, "FP 2.1" transport layer): routing core (routing table, leaf set, neighborhood set), join and maintenance protocols, socket transport with NAT traversal, plus PAST, SCRIBE, aggregation, Glacier, multi-ring.Source/com.p2pframework/src/com/p2pframework/network/freepastry/— the LibreSocial adapter: factory chain for real Internet/NAT deployments, id mapping, secure-join prototype, back-off layer, traffic/message counters.Source/com.p2pframework/src/com/p2pframework/ring/— the "ring" abstraction: several isolated Pastry networks (one per installation/community), bootstrap-address caching, lifeness probing, XML persistence of known rings.
Capacity/load-balancing mechanisms from the later publications (Adaptive Chord, capacity-aware storage indirection, CapSearch, capacity management) are not present in this code base as of 2026: the overlay is still the homogeneous Pastry DHT of the 2001 papers, with only the hooks those designs need (attribute export, id conversion, ring bookkeeping) — see "Design options".
Current implementation (as of 2026)
Key classes and packages (real paths)
| Path | Role |
|---|---|
Source/rice.freepastry/src/rice/pastry/Id.java |
160-bit node/object ids (IdBitLength = 160, nlen = 5 ints), digit-wise distance getDistance(...), Id.build(byte[]) |
.../rice/pastry/routing/RoutingTable.java |
Pastry routing table; rows = IdBitLength / idBaseBitLength, cols = 1 << idBaseBitLength, maxEntries per slot, RouteSet observable as NodeSetEventSource |
.../rice/pastry/leafset/LeafSet.java, SimilarSet.java |
leaf set with merge(...) and half-set (SimilarSet) bookkeeping |
.../rice/pastry/routing/Router.java, .../rice/pastry/standard/StandardRouter.java, RapidRerouter |
forwarding with re-routing on failure |
.../rice/pastry/join/JoinProtocol.java, JoinRequest.java, InitiateJoin.java and .../rice/pastry/standard/ConsistentJoinProtocol.java |
join (JoinRequest state flags such as HAS_LEAFSET) and consistent-join verification with re-sends to failed peers |
.../rice/pastry/transport/TransportPastryNodeFactory.java |
assembles one node: new RoutingTable(localhandle, rtMax, rtBase, pn), new LeafSet(localhandle, lSetSize, routeTable), RapidRerouter, maintenance frequencies |
.../rice/pastry/PastryNodeFactory.java |
reads pastry_rtMax, pastry_rtBaseBitLength, pastry_lSetSize from the environment |
.../rice/pastry/socket/** |
socket transport, RendezvousSocketPastryNodeFactory/RendezvousSocketNodeHandle (firewalled peers via rendezvous), LivenesSourceRouteForwardStrategy |
.../org/mpisws/p2p/transport/wire/ringidentification/RingIDTransportLayer.java, RingIDServiceProvider.java |
LibreSocial addition: transport wrapper that stamps/probes a per-ring UUID so two overlays on the same wire protocol can be told apart (PastryNode.getRingIDServiceProvider()) |
.../rice/p2p/multiring/** |
FreePastry multi-ring experiment (RingId, RingCertificate, MultiringNode) — in the fork, p2p_multiring_base = 2 configured, not used by the framework |
Source/com.p2pframework/src/com/p2pframework/network/freepastry/PastryNetwork.java |
the Network implementation (886 lines): creates/boots the Pastry node, exposes monitoring attributes |
…/network/freepastry/InternetPastryNodeFactory.java |
deployment factory (666 lines): NAT policy, external-address probing through the bootstrap, UPnP port opening, reachability check |
…/network/freepastry/MonitoredSocketPastryNodeFactory.java |
attaches traffic/message counters and the back-off layer |
…/network/freepastry/IDFactory.java, PastryID.java, PastryIP.java, IPFactory.java |
com.p2pframework.network.ID ↔ Pastry Id mapping plus a BigDecimal converter used by the monitoring/SkyEye id space |
…/network/freepastry/SecureJoinProtocol.java, SecureInitiateJoin.java, SecureJoinRequest.java, AuthorisationCheckMessage.java, AuthorisationProofMessage.java, EncryptPRawMessage.java |
join-time authorisation/proof exchange (present, not wired — see below) |
…/network/freepastry/backofflayer/** |
BackOffLayerImpl, BackOffMessageWrapper, BackOffLayerConfig: re-queueing/back-off of outgoing messages to prevent loss under congestion |
Source/com.p2pframework/src/com/p2pframework/ring/Ring.java, PastryRingManager.java, RingManager.java, RingDispatcher.java, PastryRingDispatcher.java, RingNetworkSettings.java, RingStatus.java |
multi-ring bookkeeping, bootstrap cache, XML persistence |
…/ring/lifeness/PastryRingLifenessChecker.java, RingConnectionVerifier.java, RingLifenessChecker.java |
out-of-band TCP/UDP reachability and ring-id probing |
Wiring
Framework owns PastryNetwork, RingDispatcher and StorageDispatcher. Boot sequence
(PastryNetwork.initPastryNodeAndBootstrapAddress() → bootPastryNode()):
ECAsymmetricKey(username, password)→ECPublicKey.toByteArray()→Id.build(bytes); the resulting PastryIdis the node id (deterministic per account); the password reference is nulled right after.- The
Ringcomes fromRingDispatcher.getCurrentRing(); the debug ring (Ring.DEBUG_RING_ID = cdefaf90-66e8-11e3-949a-0800200c9a66) is rejected in non-debug mode. - Bind address: the ring's
RingNetworkSettings.localInterface/localPort; for a non-single-node ring the local address is auto-detected by opening a clientSocketto the bootstrap and readinggetLocalAddress();-Dlibresocial.bindLoopback=truerewrites bind address and bootstrap host to127.0.0.1(commitadfbf158c, 2026-07-07, for multi-node tests on one host). - Optional port forwarding:
getExternalMostAddress(...)through the bootstrap, then UPnP withnat_handler_class = rice.pastry.socket.nat.sbbi.SBBINatHandler(findFireWall,findAvailableFireWallPort(bindport, pfPort, 5, "LibreSocial"),openFireWallPort(...)); the result is published asexternal_address. - Factory chain
MonitoredSocketPastryNodeFactory→InternetPastryNodeFactory→RendezvousSocketPastryNodeFactory→SocketPastryNodeFactory→TransportPastryNodeFactory. The per-node transport stack is wire layer →MagicNumberTransportLayer→RingIDTransportLayer→ source-routing layer →PriorityTransportLayer→BackOffLayerImpl; the byte counter is attached ingetMagicNumberTransportLayer(), the message counter and the back-off wrapper ingetPriorityTransportLayer(), which returnsnew BackOffLayerImpl(priorityTransportLayer, 1000, 5, 30, 30, liveness, env). node.addLeafSetListener(ring)/node.addRouteSetListener(ring):Ringis aNodeSetListenerand continuously refreshes the bootstrap-address cache.node.getRingIDServiceProvider().setLocalUUID(ring.getId()), thennode.boot(bootAddress); the caller blocks onnode.isReady()/node.joinFailed()with a 650 000 ms timeout (node.wait(1000)loop) and recordsjoinNetworkDuration.
Ring.nodeSetUpdate(...) accepts only RendezvousSocketNodeHandles reporting canContactDirect(),
so firewalled (rendezvous-only) peers are never advertised as bootstraps.
Notable parameters
Defaults live in Source/rice.freepastry/config/freepastry.params; the unit-test bundle ships a
variant at Source/com.p2pframework.unittests/resources/freepastry.params
(pastry_factory_bootsInParallel = 1, pastry_socket_scm_max_open_sockets = 300,
pastry_socket_scm_num_ping_tries = 5, scm_backoff_limit = 5, p2p_past_messageTimeout = 30000).
- Overlay geometry:
pastry_rtBaseBitLength = 4(⇒ 40 rows × 16 columns for a 160-bit id space),pastry_rtMax = 1,pastry_lSetSize = 24. - Maintenance:
pastry_leafSetMaintFreq = 60s,pastry_routeSetMaintFreq = 900s,pastry_protocol_periodicLeafSet_ping_neighbor_period = 20000,..._lease_period = 30000,..._request_lease_throttle = 10000(ms). - Consistent join:
pastry_protocol_consistentJoin_retry_interval = 30000,..._failedRetentionTime = 900000,..._cleanup_interval = 300000,..._maxFailedToSend = 20,..._max_time_to_be_scheduled = 15000(ms, read inConsistentJoinProtocol). - Liveness/failure detection:
pastry_socket_scm_ping_delay = 800(with exponential back-off),pastry_socket_scm_num_ping_tries = 4,pastry_socket_srm_default_rto = 3000,pastry_socket_srm_num_source_route_attempts = 8,..._check_dead_throttle = 300000. - Locality and partitions:
transport_use_pns = true,pns_num_rows_to_use = 10,partition_handler_check_interval = 300000,..._bootstrap_check_rate = 0.05,..._max_history_age = 5400000. - Set in
PastryNetwork:pastry_socket_writer_max_queue_length = 100(file default 30),internet_test_firewall = true,loglevel = FINEwhenFramework.LOG_PASTRYis on (defaultWARNING). - Back-off layer (
MonitoredSocketPastryNodeFactory): time slot 1 000 ms, 5 retries before a failure is passed up, 30 queued messages per routing-table node, 30 waiting re-transmissions (-1means unlimited inBackOffLayerConfig). - Framework side:
Configurationring-manager update interval 30 000 ms (RingExporterthread writingbootstraps.xml), start port 9001 with port range 1000, boot timeout 650 000 ms, lifeness probe timeout 5 000 ms.
Design options and decision
(The publications document the alternatives discussed at the time; where a link to this specific code is not stated in the sources, the rationale is reconstructed and marked as such.)
- Centralized directory/tracker vs. DHT. The 2008 architecture papers reject the client-server model (administration cost, single point of failure, censored/monitored infrastructure) for a self-organizing DHT. Pastry was chosen as the substrate and FreePastry as an available Java implementation, which also made PAST (replicated storage) and SCRIBE (topic multicast) directly reusable. Trade-off accepted: O(log N) multi-hop routing and eventual consistency instead of one authoritative query, plus the operational burden of NAT traversal.
- Pastry vs. Chord/CAN/Tapestry. The 2001 Pastry paper argues for proximity-aware neighbour selection (≈50 % overhead over the direct path), small routing state (b = 4 ⇒ ~75 entries and 5 hops at 10^6 nodes; |L| = 16, |M| = 32 in the paper's configuration) and built-in node-state listeners. Reconstructed: the FreePastry Java code base, the bundled PAST/SCRIBE stack and the socket layer with rendezvous handling of firewalled nodes were the practical tie-breaker for an implementation carried by project groups.
- Homogeneous overlay vs. capacity-aware overlay (Adaptive Chord). The 2011 thesis and the 2013
NetSys paper drop the assumption that peers contribute equal capacity (Zipf-like object
popularity, heterogeneous access bandwidth). Rejected alternatives there: virtual peers /
unequal key-range assignment (a weak peer cannot serve the load its share of the id space
attracts, and range splitting breaks the routing invariants), peer/file repositioning
(re-inserting state and invalidating referring pointers is too costly under churn), PAST file
diversion and Beehive-style caching (uncontrolled replica placement; a P2P-OSN must know every
copy location because updates have to reach all replicas), and fully capacity-aware overlays
(invasive, not incrementally deployable into an installed base). Chosen: storage indirection on
top of a homogeneous overlay — the responsible peer stays index holder and names a supplier
peer picked for free upload capacity. Capacity is encoded into a second id space,
ID = min(2^m − 1, (2^m − 1)·v/M), so a second (capacity) overlay sorts peers by free resources by construction; peers belowκ = min(0.2·v_max, 70 kbit/s)stay out of it. Balancing runs every 4 minutes withγ = 0.2,ε = 0.1·v_maxand an adaptive target bandwidthω(start 150 kbit/s, ±20 %), and position updates only on capacity changes larger thanεto avoid self-inflicted churn. Reported effect (PeerfactSim.KOM, 1 000 peers, 10 000 files, Zipf 0.6, Weibull churn): overloaded peers 160.4 → 24.5, download time 806.7 s → 85.9 s without churn and ≈2× faster with churn. Status here: not implemented —com.p2pframework*has no capacity, supplier or indirection classes and the evaluation is simulator-based; that the overlay was deliberately left untouched while only attributes and the ring abstraction were prepared is a reconstructed reading. - Overlay monitoring: central collector vs. gossip aggregation vs. DHT-derived tree. The 2009
papers and the 2010 dissertation weigh a central collector (simple, but a bottleneck and a single
point of trust/failure), pure gossip such as PushSum (cheap and robust, but the aggregate is a
sampled approximation that converges slowly and cannot be addressed per region), and an
over-overlay whose aggregation tree is derived deterministically from the peers' ids in the KBR
itself (SkyEye.KOM: coordinators/domains per id range, maintenance carried by metric updates
only, aggregation to the root and distribution back to the leaves, hot nodes offloaded to
support peers). Chosen: the id-derived tree, because aggregates are exact per id range, queries
can be addressed by range, and the tree reuses the overlay's own neighbour state — measured at
~110 byte/s per peer for system metrics with global-view staleness below 200 s in a 37-PC,
500-peer testbed. The 2016 Convex-Hull-Watchdog paper addresses the attack surface this creates
(peers inflating subtree aggregates).
PastryID.Converterstill maps ids for that tree (PastryId↔BigDecimalin (0, 1]). Status here (2026): partial —MonitoringThreadcollects network/message/storage attributes and writes SQLite and gnuplot output, but the SkyEye protocol classes (monitoring/message/UpdateContent.java,PropagateContent.java,TopologyManagementContent.java,query/QueryRequest.java,support/SupportRequest.java) andmonitoring/loadBalancing/LoadBalancingInfo.java("needed in order to loadbalance the sky eye tree") are referenced by nothing, i.e. no aggregation tree runs in the open-source build. - One global overlay vs. multiple rings. Chosen: multiple isolated rings (
Ring= UUID + bootstrap set + network settings), because a public installation must be able to join an existing community network, keep test networks apart, and survive the loss of a bootstrap list. Cost: split id spaces and the need to identify a ring at the wire level — solved by the customRingIDTransportLayer/RingIDServiceProviderinstead of the upstreamrice/p2p/multiringlayer, which is present but unused. - Liveness: rely on Pastry's failure detector vs. explicit probing. Chosen: both. Pastry's
ping/lease machinery maintains the overlay; the ring layer runs its own TCP+UDP connectivity
check and ring-id probe before handing out a bootstrap address, because a stale
bootstraps.xmlwould make joining impossible. Trade-off: probing latency bounded bymaxTriesand the 5 s probe timeout, paid for join reliability.
Technical details
Identifier space
rice.pastry.Iduses 160 bits (IdBitLength = 160) — this differs from the 128-bit space of the 2001 paper; digits are extracted in base 2^b (getDigit(i, b)).- Object ids come from
PastryIdFactory(SHA-based) andIDFactory, which cachesId → PastryID. - Node ids are identity-bound:
PastryNetwork.createNodeAndBoot()derives them fromECPublicKey.toByteArray()viaId.build(...). Re-login under the same account therefore returns to the same point of the id space, and the node id doubles as the public-key fingerprint used by the security layer.
Routing and node state
- Classic Pastry state: routing table of 40 × 16 slots with one handle per slot, leaf set of 24,
neighborhood set for proximity, greedy digit-by-digit forwarding with
RapidRerouter, and source routes for firewalled destinations (pastry_socket_srm_num_source_route_attempts = 8). - Applications obtain
Endpoints throughnode.buildEndpoint(app, name);PastryNetworkregisters a dummy endpoint only to answerisResponsibleFor(ID)viaendpoint.range(..., true). - Wire compatibility while migrating an existing ring is kept by pinning
pastry_protocol_router_routeMsgVersion = 1.
Join, membership and ring lifecycle
- Join is upstream Pastry: bootstrap →
JoinRequest(state transfer,HAS_LEAFSET) → consistent-join verification across the leaf set, retried every 30 s. Ring.getAvailableBootstrap(maxTries)picks a random cached bootstrap; if the ring was loaded from disk (remoteNodesAreAlive == false) each candidate is verified byRingLifenessChecker.isAddressAlive(...)and dead entries are evicted. A single-node ring boots from its own bind address.PastryRingLifenessCheckerrefuses to run on Pastry's selector thread (deadlock guard), uses a 5 000 ms timer, and counts a peer as alive only when both the TCP and the UDP check succeed. Interface addresses of typeInet6Addressare skipped — the ring layer is IPv4-only.PastryRingManager.discoverRing(target)scans up to 1 000 consecutive ports for a free local port and iterates local interfaces (preferred one first, loopback-only under-Dlibresocial.bindLoopback) untildiscoverRemoteRing(...)returns a UUID.- Persistence:
<lifesocial-address-cache><rings><ring id name isSingleNodeRing>with nested network settings and<bootstrap>host:port</bootstrap>entries in<application directory>/bootstraps.xml, rewritten every 30 s by theRingExporterthread.Ring.getRingStatus()reportsLOCAL,ONLINE,UNKNOWNorOFFLINE. - The debug ring (
Ring.createDebugRing()) still derives bind/bootstrap addresses from the deprecatedConfigurationkeysBINDADDRESS/BINDPORT/BOOTPORT/BOOTADDRESSand marks the ring alive without probing — used by the unit tests and the tester bundle.
Ring identification on the wire
RingIDTransportLayer frames messages with the local ring UUID and answers
requestRemoteRingID(addr, callback) probes; RingConnectionVerifier is the client side, used by
the lifeness checker and by InternetPastryNodeFactory.isReachableFromExternalNode. This keeps a
node from joining a different LibreSocial ring that happens to speak the same FreePastry protocol
on the same port.
NAT traversal and firewall handling
InternetPastryNodeFactory ("designed for real deployments (with NATs)", modified by project group
2013) provides NAT-policy constants (ALWAYS/PREFIX_MATCH/NEVER,
OVERWRITE/USE_DIFFERENT_PORT/FAIL/RENDEZVOUS), external-address discovery by asking
externally reachable nodes (findExternalAddress, one address per NAT hop), reachability
verification through a bootstrap, and UPnP port opening. Firewalled nodes still participate via
rendezvous handles but are excluded from the bootstrap cache.
Integration points
- Messaging:
com.p2pframework.message/messagedispatcheruse PastryEndpoints andPastryIDs as keys; SCRIBE channels are wrapped incom.p2pframework.message.scribe(PastryTopicChannel.registTime→NETWORK_USER_REGISTRATION_TIME). - Storage:
PastryNetworkre-initialisesPastryStorageDispatcherwhen the current ring changes (initStorage()), so storage keys are scoped to one ring. - Monitoring:
PastryNetwork.getAttributes()publishes ~20 attributes (NETWORK_NODES,NETWORK_DATA_SENT{,_RATE},NETWORK_DATA_RECEIVED{,_RATE},NETWORK_MESSAGES_SENT{,_RATE},NETWORK_MESSAGES_SENT_SIZE,NETWORK_MESSAGES_DROPPED_COUNT,NETWORK_MESSAGES_ENQUEUED_COUNT,NETWORK_PASTRY_DATA_SENT{,_RATE},NETWORK_PASTRY_DATA_READ{,_RATE},NETWORK_MEMORY_USAGE_SIZE,NETWORK_MEMORY_TOTAL_SIZE,NETWORK_NODE_JOINNETWORK_TIME,NETWORK_USER_REGISTRATION_TIME) ascom.p2pframework.message.aggregate.Attributewith anAggregationStrategy(sumfor counters,meanfor durations, plus generated min/max/mean variants); rates come fromRateBuffer(5)windows, byte counts fromPastryNetworkTrafficCounter/PastryNetworkMessageCounter.
Present but not active (verified 2026)
Several overlay-adjacent mechanisms exist without being wired into a running node — relevant when reading older descriptions of the system:
rice/p2p/multiring/**(FreePastry multi-ring withRingCertificate) — superseded by the LibreSocialRing+RingIDTransportLayerapproach;p2p_multiring_base = 2remains in the parameter file.rice/p2p/glacier/v2/**(firewall-piercing helper overlay) — not referenced bycom.p2pframework; rendezvous handles and UPnP are used instead.SecureJoinProtocol(extendsConsistentJoinProtocol) together withSecureInitiateJoin,SecureJoinRequest,AuthorisationCheckMessage,AuthorisationProofMessageandEncryptPRawMessage— no instantiation anywhere in the current tree, so joining is currently not authenticated at the overlay level.com.p2pframework.monitoring.message.*andmonitoring/loadBalancing/LoadBalancingInfo(above).
Evolution and supersession
- 2007–2010 (LifeSocial.KOM). FreePastry 2.x (FP 2.1 transport) is adopted essentially as-is; node identity is already public-key based; the ISM 2008 and Podrajanski 2008 papers describe the overlay → storage → dispatcher → cache → plug-in layering the code still follows.
- 2011–2014 (Paderborn project groups). The factory chain is rewritten for the residential
Internet (
InternetPastryNodeFactory, "modified by PG2013"), the ring abstraction (Ring,PastryRingManager,lifeness) is introduced, and the ring UUID is pushed down into the transport (RingIDTransportLayer). Bootstrapping becomes a discover-then-join flow rather than a static bootstrap address; the deprecatedConfigurationkeys survive only for the debug ring. - 2015. Reliability and security hardening around the join path:
backofflayer(observed message loss, commite1f9a3b34"Integrated BackoffLayer to prevent MessageLoss"), UPnP port forwarding (e27109f72), STUN experiments (com.p2pframework.stun), and automatic network interface selection, later partially disabled (a94634329). - 2019–2020. Repository migrated to Git (
4a1e9a74c"ported initial commit"). The 2020 framework paper and the 2020 dissertation give the consolidated description of the overlay and of the monitoring/capacity mechanisms and supersede the 2008–2013 accounts; the 2017 bug summary is explicitly marked as possibly outdated. - 2025–2026 revival. The setup guide and the 2025 revival thesis document rebuilding the legacy
stack. The 2026 refactoring moved the fork to Gradle + bnd OSGi bundles and Java 17
(
6b651a1e1replaced JavaSE-1.7 in allbnd.bndfiles), applied OpenRewrite cleanups (3a9e918d0), removed deprecated constructs (b5430d03c) and trimmed logging (6a41544d8,80712ee29); multi-node testing moved to six Docker containers (2fc975517) with-Dlibresocial.bindLoopback(adfbf158c) and the port fallback indiscoverRing.RingConnectionVerifier/PastryRingLifenessCheckernow report the real discovery exception instead of swallowing it. - Still open (2026). IPv4-only ring layer; boot wait is a blocking
node.wait(1000)loop with an 11-minute timeout; unauthenticated join; SkyEye aggregation and the capacity/Adaptive-Chord mechanisms exist only as classes or publications; Pastry unit tests disabled (fd8d7000e).
Related publications
Overlay and storage substrate
- Pastry: Scalable, decentralized object location and routing for large-scale peer-to-peer systems (2001) — the routing table / neighbourhood set / leaf set design implemented here.
- PAST: A large-scale, persistent peer-to-peer storage utility (2001) —
rice/p2p/past, used by the storage dispatcher. - Storage Management and Caching in PAST, a Large-Scale, Persistent Peer-to-Peer Storage Utility (2001)
- A Peer-to-Peer based Framework for Large-Scale Social Networking Platforms (2008) — first LifeSocial core architecture over FreePastry.
Ring management, NAT traversal and the framework (project reports)
- A Distributed Platform for Multimedia Communities (2008)
- LifeSocial.KOM: A P2P-based Platform for Secure Online Social Networks (Demo-Paper, IEEE P2P 2010) (2010)
- A Distributed Framework for Social Networks — Final Report (Project Group 2011) (2012)
- A Peer-to-Peer Framework for Social Networks — Dokumentation (Abschlussbericht der Projektgruppe 2012, UPB Paderborn) (2013) — documents the PG2013-modified factory chain.
- A P2P-Framework for Social Networks (2013)
- A Peer-to-Peer Framework for Social Networks — Final Report (Project Group 2013/14, LifeSocial) (2014)
- LibreSocial Report – Summary of known Bugs (maybe outdated) (2017)
Monitoring over the overlay
- SkyEye.KOM: An Information Management Over-Overlay for Getting the Oracle View on Structured P2P Systems (2008)
- Development and Evaluation of a Framework for Monitoring Peer-to-Peer Systems (2009)
- Monitoring and Management of P2P Overlays — How to coordinate millions of autonomous peers to provide controlled quality of service? (Foliensatz) (2009)
- Monitoring and Management of Peer-to-Peer Systems (2010) — SkyEye tree design, capacity-based peer search, MAPE loop, LifeSocial.KOM platform chapter.
- LifeSocial.KOM: A Secure and P2P-based Solution for Online Social Networks (2011)
- Convex Hull Watchdog: Mitigation of Malicious Nodes in Tree-based P2P Monitoring Systems (2016)
- SkyEye: A tree-based peer-to-peer monitoring approach (2017)
Load balancing and capacity (research above this overlay)
- Adaptives Loadbalancing für strukturierte Peer-to-Peer-Netzwerke am Beispiel von Chord (2011)
- Adding Capacity-Aware Storage Indirection to Homogeneous Distributed Hash Tables (2013) — Adaptive Chord.
- Adding Capacity-Aware Storage Indirection to Homogeneous Distributed Hash Tables (Vortragsfolien, NetSys 2013) (2013)
- CapSearch: Capacity-based Search in highly dynamic Peer-to-Peer Networks (2017)
- Capacity Management Protocol for a Structured P2P-based Online Social Network (2020)
Platform and current state
- LibreSocial: A peer-to-peer framework for online social networks (2020)
- Peer-to-Peer Mechanisms for Fully Decentralized, Secure and Scalable Online Social Networks (2020)
- Systematic Evaluation of LibreSocial — A Peer-to-Peer Framework for Online Social Networks (2020)
- Running LibreSocial: A Legacy Java Project Setup Guide (2025)
- Reviving LibreSocial: Error Fixes and a Baseline Evaluation on Modern Systems (2025)