from interface PeerProvider
337904
public void generateReport (ClientObject caller, String type,
                                PeerService.ResultListener listener)
        throws InvocationException
    {
        listener.requestProcessed(_repmgr.generateReport(type));
    }
254275
public void setPeerId(ByteBuffer peerId) {
    if (peerId != null) {
      this.peerId = peerId;
      this.hexPeerId = TorrentUtils.byteArrayToHexString(peerId.array());
    } else {
      this.peerId = null;
      this.hexPeerId = null;
    }
  }
465674
public void addPeer(TrackedPeer peer) {
    this.peers.put(new PeerUID(peer.getAddress(), this.getHexInfoHash()), peer);
  }
685883
private CompletableFuture<Void> requestBootstrapFromPeer(MemberId peer) {
    LOGGER.trace("Sending bootstrap request to {} for {}", peer, mapName);
    return clusterCommunicator.<MemberId, Void>send(
        bootstrapMessageSubject,
        localMemberId,
        serializer::encode,
        serializer::decode,
        peer)
        .whenComplete((updates, error) -> {
          if (error != null) {
            LOGGER.debug("Bootstrap request to {} failed: {}", peer, error.getMessage());
          }
        });
  }
728181
def indication(self, pdu):
        """"""
        if _debug: UDPDirector._debug("indication %r", pdu)

        # get the destination
        addr = pdu.pduDestination

        # get the peer
        peer = self.peers.get(addr, None)
        if not peer:
            peer = self.actorClass(self, addr)

        # send the message
        peer.indication(pdu)
1073755
@ObjectiveCName("sendStickerWithPeer:withSticker:")
    public void sendSticker(Peer peer, Sticker sticker) {
        modules.getMessagesModule().sendSticker(peer, sticker);
    }
1235870
function Peer (options) {
  EventEmitter.call(this)
  bindFns(this)

  extend(this, options)
  var addr = this.address
  var hp = addr.split(':')
  this.host = hp[0]
  this.port = Number(hp[1])
  this._deliveryTrackers = []
  this.setMaxListeners(0)
  this._debug('new peer')
}
879026
function pushOutBoundPeersToExplorer(){
	if(!conf.IF_BYZANTINE)
		return;
	if (conf.bLight )
		return;
	findOutboundPeerOrConnect
	(
		explorerUrl,
		( err, oWsByExplorerUrl ) =>
		{
			if ( ! err )
			{
				let arrOutboundPeerUrls = arrOutboundPeers.map(function (ws) {
					return ws.peer;
				});
				sendJustsaying( oWsByExplorerUrl, 'push_outbound_peers', arrOutboundPeerUrls );
			}
		}
	);
}
396762
@Override
    public Association addServerAssociation(String peerAddress, int peerPort, String serverName, String assocName)
            throws Exception {
        return addServerAssociation(peerAddress, peerPort, serverName, assocName, IpChannelType.SCTP);
    }
795875
@Override
  public void _LocalPeer_setURI(String uri) throws MBeanException {
    // validate uri
    try {
      new URI(uri);

      getMutableConfiguration().setStringValue(OwnDiameterURI.ordinal(), uri);

      if (logger.isInfoEnabled()) {
        logger.info("Local Peer URI successfully changed to '" + uri + "'. Restart to Diameter stack is needed to apply changes.");
      }
    }
    catch (URISyntaxException use) {
      throw new MBeanException(use);
    }
  }
224290
private void add(Peer peer) {
		String id = peer.getId();
		peers.put(id, peer);
		timeouts.put(id, executor.schedule(new Deactivate(id), delay, MILLISECONDS));
		notifyConnected(new Builder(peer).status(Status.CONNECTED).build());
		notifyActive(peer);
	}
899640
function loadProviders (store, cid, callback) {
  pull(
    store.query({ prefix: makeProviderKey(cid) }),
    pull.map((entry) => {
      const parts = entry.key.toString().split('/')
      const lastPart = parts[parts.length - 1]
      const rawPeerId = utils.decodeBase32(lastPart)
      return [new PeerId(rawPeerId), readTime(entry.value)]
    }),
    pull.collect((err, res) => {
      if (err) {
        return callback(err)
      }

      return callback(null, new Map(res))
    })
  )
}
644792
public Collection<ProposalResponse> queryByChaincode(QueryByChaincodeRequest queryByChaincodeRequest, Collection<Peer> peers) throws InvalidArgumentException, ProposalException {
        return sendProposal(queryByChaincodeRequest, peers);
    }
876045
def subscribe(self, peer_jid):
        
        self.roster.subscribe(aioxmpp.JID.fromstr(peer_jid).bare())
388971
def connectPeer(self, peer):
        
        return self.conns.connectCached(endpoint.Q2QEndpoint(self.svc,
                                                             self.addr,
                                                             peer,
                                                             PROTOCOL_NAME),
                                        self.clientFactory)
779219
@Override
    public synchronized PubSubOutputHandler createPubSubOutputHandler(Neighbour neighbour)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "createPubSubOutputHandler", new Object[] { neighbour });

        PubSubOutputHandler handler =
                        _pubSubRealization.createPubSubOutputHandler(neighbour);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "createPubSubOutputHandler", handler);

        return handler;
    }
1203412
def peers(cls):
        """"""
        contentType = ContentType.objects.get_for_model(cls)
        return cls.objects.filter(content_type=contentType)