Compound Module ChordModules

Package: oversim.overlay.chord
File: src/overlay/chord/Chord.ned

Implementation of the Chord KBR overlay as described in "Chord: A Scalable Peer-to-Peer Lookup Protocol for Internet(1,2) Applications" by I. Stoica et al. published in Transactions on Networking.

Author: Ingmar Baumgart, Markus Mauch

Usage diagram:

The following diagram shows usage relationships between types. Unresolved types are missing from the diagram. Click here to see the full picture.

Inheritance diagram:

The following diagram shows inheritance relationships for this type. Unresolved types are missing from the diagram. Click here to see the full picture.

Properties:

Name	Value	Description
display	i=block/network2

Gates:

Name	Direction	Description
udpIn	input	gate from the UDP layer
udpOut	output	gate to the UDP layer
tcpIn	input	gate from the TCP layer
tcpOut	output	gate to the TCP layer
appIn	input	gate from the application
appOut	output	gate to the application

Unassigned submodule parameters:

Name	Type	Description
chord.rpcUdpTimeout	double	default timeout value for direct RPCs
chord.rpcKeyTimeout	double	default timeout value for routed RPCs
chord.optimizeTimeouts	bool	calculate timeouts from measured RTTs and network coordinates
chord.rpcExponentialBackoff	bool	if true, doubles the timeout for every retransmission
chord.localPort	int	UDP port for overlay messages
chord.overlayId	int	identifies the overlay this node belongs to (used for multiple overlays)
chord.debugOutput	bool	enable debug output
chord.keyLength	int	overlay key length in bits
chord.nodeId	string	optional nodeId as string in hexadecimal notation
chord.useCommonAPIforward	bool	enable CommonAPI forward() calls
chord.drawOverlayTopology	bool	draw arrow to successor node?
chord.hopCountMax	int	maximum number of overlay hops
chord.recNumRedundantNodes	int	numRedundantNodes for recursive routing
chord.joinOnApplicationRequest	bool	only join the overlay on application request
chord.collectPerHopDelay	bool	delay statistics for single hops
chord.routeMsgAcks	bool	use RPCs for route messages
chord.lookupRedundantNodes	int	number of next hops in each step
chord.lookupParallelPaths	int	number of parallel paths
chord.lookupParallelRpcs	int	number of nodes to ask in parallel
chord.lookupVerifySiblings	bool	true, if siblings need to be authenticated with a ping
chord.lookupMajoritySiblings	bool	true, if sibling candidates are selected by a majority decision if using parallel paths
chord.lookupMerge	bool	true, if parallel Rpc results should be merged
chord.lookupFailedNodeRpcs	bool	communicate failed nodes
chord.lookupStrictParallelRpcs	bool	limited the number of concurrent rpcs to parameter parallelRpcs
chord.lookupUseAllParallelResponses	bool	merge all parallel responses from earlier steps
chord.lookupNewRpcOnEveryTimeout	bool	send a new RPC immediately after an RPC timeouts
chord.lookupNewRpcOnEveryResponse	bool	send a new RPC after every response, even if there was no progress
chord.lookupFinishOnFirstUnchanged	bool	finish lookup, if the last pending RPC returned without progress
chord.lookupVisitOnlyOnce	bool	if true, the same node is never asked twice during a single lookup
chord.lookupAcceptLateSiblings	bool	if true, a FindNodeResponse with sibling flag set is always accepted, even if it is from a previous lookup step
chord.routingType	string	default routing mode (iterative, semi-recursive,...)
chord.rejoinOnFailure	bool	rejoin after loosing connection to the overlay?
chord.sendRpcResponseToLastHop	bool	needed by KBR protocols for NAT support
chord.recordRoute	bool	record visited hops on route
chord.dropFindNodeAttack	bool	if node is malicious, it tries a findNode attack
chord.isSiblingAttack	bool	if node is malicious, it tries a isSibling attack
chord.invalidNodesAttack	bool	if node is malicious, it tries a invalidNode attack
chord.dropRouteMessageAttack	bool	if node is malicious, it drops all received BaseRouteMessages
chord.measureAuthBlock	bool	if true, measure the overhead of signatures in rpc messages
chord.restoreContext	bool	if true, a node rejoins with its old nodeId and malicious state
chord.successorListSize	int	max number of successors in the SuccessorList
chord.joinRetry	int	after joinRetry unsuccessful join requests, we fetch a need bootstrap node from the GlobalNodeList
chord.stabilizeRetry	int	retries before a successor is considered failed
chord.joinDelay	double	delay between join retries (sec)
chord.stabilizeDelay	double	stabilize interval (sec)
chord.fixfingersDelay	double	fix_fingers interval (sec)
chord.aggressiveJoinMode	bool	use modified (faster) JOIN protocol
chord.checkPredecessorDelay	double	checkPredecessor interval (sec)
chord.extendedFingerTable	bool	use the extended finger table?
chord.numFingerCandidates	int	number of fingers when using extended finger table
chord.proximityRouting	bool	use proximity routing
chord.memorizeFailedSuccessor	bool	do not use failed sucessor again and inform new successor
chord.mergeOptimizationL1	bool	enable merge optimization OPL1
chord.mergeOptimizationL2	bool	activate merge optimization OPL2
chord.mergeOptimizationL3	bool	activate merge optimization OPL3
chord.mergeOptimizationL4	bool	activate merge optimization OPL4

Source code:

//
// Implementation of the Chord KBR overlay as described in
// "Chord: A Scalable Peer-to-Peer Lookup Protocol for Internet
// Applications" by I. Stoica et al. published in Transactions on Networking.
//
// @author Ingmar Baumgart, Markus Mauch
//
module ChordModules like IOverlay
{
    parameters:
        @display("i=block/network2");

    gates:
        input udpIn;   // gate from the UDP layer
        output udpOut;    // gate to the UDP layer
        input tcpIn;    // gate from the TCP layer
        output tcpOut;    // gate to the TCP layer
        input appIn;   // gate from the application
        output appOut;    // gate to the application

    submodules:
        chord: Chord {
            parameters:
                @display("p=60,60");

        }
        fingerTable: ChordFingerTable {
            parameters:
                @display("p=150,60");
        }
        successorList: ChordSuccessorList {
            parameters:
                @display("p=240,60");

        }
    connections allowunconnected:
        udpIn --> chord.udpIn;
        udpOut <-- chord.udpOut;
        appIn --> chord.appIn;
        appOut <-- chord.appOut;
}