// Called when a peer we're trying to connect to sends us a message
private void processNewPeer(SocketChannel c) throws IOException {
ByteBuffer message = ChannelHelper.readBytes(c, 4);
String recognize = utf8.decode(message).toString();
if (!recognize.equals("bam!")) {
// Connected to something that wasn't a BAMPong client...
c.close();
Peer p = new_peers.remove(c);
log("Closing attempt to " + p.getName() + " got " + recognize);
return;
}
// Assemble response
ByteBuffer name = utf8.encode(nick);
message = ByteBuffer.allocateDirect(name.limit() + 10); // id(4), port(4), name(2+limit)
message.putInt(id);
message.putInt(getPort());
ChannelHelper.putString(message, name);
message.flip();
// Send message
c.write(message);
// Move socket to connected peers.
Peer peer = new_peers.remove(c);
peers.put(c, peer);
sockets.put(peer, c);
}
// Check that it starts downloading the block chain correctly on request.
@Test
public void startBlockChainDownload() throws Exception {
Block b1 = createFakeBlock(blockStore).block;
blockChain.add(b1);
Block b2 = makeSolvedTestBlock(b1);
blockChain.add(b2);
connect();
fail.set(true);
peer.addEventListener(
new AbstractPeerEventListener() {
@Override
public void onChainDownloadStarted(Peer p, int blocksLeft) {
if (p == peer && blocksLeft == 108) fail.set(false);
}
},
Threading.SAME_THREAD);
peer.startBlockChainDownload();
List<Sha256Hash> expectedLocator = new ArrayList<Sha256Hash>();
expectedLocator.add(b2.getHash());
expectedLocator.add(b1.getHash());
expectedLocator.add(unitTestParams.getGenesisBlock().getHash());
GetBlocksMessage message = (GetBlocksMessage) outbound(writeTarget);
assertEquals(message.getLocator(), expectedLocator);
assertEquals(Sha256Hash.ZERO_HASH, message.getStopHash());
}
@Test
public void invDownloadTxMultiPeer() throws Exception {
// Check co-ordination of which peer to download via the memory pool.
VersionMessage ver = new VersionMessage(unitTestParams, 100);
InetSocketAddress address = new InetSocketAddress("127.0.0.1", 4242);
Peer peer2 = new Peer(unitTestParams, ver, new PeerAddress(address), blockChain, memoryPool);
peer2.addWallet(wallet);
VersionMessage peerVersion = new VersionMessage(unitTestParams, OTHER_PEER_CHAIN_HEIGHT);
peerVersion.clientVersion = 70001;
peerVersion.localServices = VersionMessage.NODE_NETWORK;
connect();
InboundMessageQueuer writeTarget2 = connect(peer2, peerVersion);
// Make a tx and advertise it to one of the peers.
BigInteger value = Utils.toNanoCoins(1, 0);
Transaction tx = createFakeTx(unitTestParams, value, this.address);
InventoryMessage inv = new InventoryMessage(unitTestParams);
InventoryItem item = new InventoryItem(InventoryItem.Type.Transaction, tx.getHash());
inv.addItem(item);
inbound(writeTarget, inv);
// We got a getdata message.
GetDataMessage message = (GetDataMessage) outbound(writeTarget);
assertEquals(1, message.getItems().size());
assertEquals(tx.getHash(), message.getItems().get(0).hash);
assertTrue(memoryPool.maybeWasSeen(tx.getHash()));
// Advertising to peer2 results in no getdata message.
inbound(writeTarget2, inv);
pingAndWait(writeTarget2);
assertNull(outbound(writeTarget2));
}
boolean initiateConnection(Connection conn_, Peer peer) {
TCPConnection conn = (TCPConnection) conn_;
try {
SocketChannel channel = SocketChannel.open();
InetSocketAddress localAddress = new InetSocketAddress(conn.host_id, 0);
channel.socket().bind(localAddress);
channel.configureBlocking(false);
try {
InetSocketAddress remoteAddress = new InetSocketAddress(peer.host(), peer.port());
if (channel.connect(remoteAddress)) {
// This only happens on Solaris when connecting locally
logger.log(Level.FINEST, "Connected!");
conn.state = Connection.State.connected_out;
conn.channel = channel;
selector.wakeup();
channel.register(selector, SelectionKey.OP_READ, conn);
initiateCER(conn);
return true;
}
} catch (java.nio.channels.UnresolvedAddressException ex) {
channel.close();
return false;
}
conn.state = Connection.State.connecting;
conn.channel = channel;
selector.wakeup();
channel.register(selector, SelectionKey.OP_CONNECT, conn);
} catch (java.io.IOException ex) {
logger.log(
Level.WARNING,
"java.io.IOException caught while initiating connection to '" + peer.host() + "'.",
ex);
}
return true;
}
public static void deleteInactivePeers(int MAX_TIME_WITHOUT_UPDATES) {
List toDelete = new ArrayList<Peer>();
List<RealtimeRoom> roomsToSave = new ArrayList<RealtimeRoom>();
// ++++++++= CLEAN ROOMs ++++++++++++++++++=
Collection<RealtimeRoom> rooms = DbUtils.loadRooms();
for (RealtimeRoom room : rooms) {
List<Peer> roomPeers = room.getPeers();
if (!roomPeers.isEmpty()) {
for (Peer peer : roomPeers) {
if (peer.getTimeSinceLastUpdate() >= RefreshCommand.MAX_TIME_WITHOUT_UPDATES) {
toDelete.add(peer);
roomsToSave.add(room);
room.removePeer(peer.getId());
}
}
} else {
if (!room.isStatic() && !room.isWaitingRoom()) { // deletable room without peers
toDelete.add(room);
}
}
}
ofy().delete().entities(toDelete);
ofy().save().entities(roomsToSave);
// LOGGER.info(inactivePeers.size() + " peers inativos deletados!");
}
@Test
public void pingPong() throws Exception {
connect();
Utils.rollMockClock(0);
// No ping pong happened yet.
assertEquals(Long.MAX_VALUE, peer.getLastPingTime());
assertEquals(Long.MAX_VALUE, peer.getPingTime());
ListenableFuture<Long> future = peer.ping();
assertEquals(Long.MAX_VALUE, peer.getLastPingTime());
assertEquals(Long.MAX_VALUE, peer.getPingTime());
assertFalse(future.isDone());
Ping pingMsg = (Ping) outbound(writeTarget);
Utils.rollMockClock(5);
// The pong is returned.
inbound(writeTarget, new Pong(pingMsg.getNonce()));
pingAndWait(writeTarget);
assertTrue(future.isDone());
long elapsed = future.get();
assertTrue("" + elapsed, elapsed > 1000);
assertEquals(elapsed, peer.getLastPingTime());
assertEquals(elapsed, peer.getPingTime());
// Do it again and make sure it affects the average.
future = peer.ping();
pingMsg = (Ping) outbound(writeTarget);
Utils.rollMockClock(50);
inbound(writeTarget, new Pong(pingMsg.getNonce()));
elapsed = future.get();
assertEquals(elapsed, peer.getLastPingTime());
assertEquals(7250, peer.getPingTime());
}
public static void init() {
EventHandler.setController(new PullBasedPeerController());
Network.init();
OverlayFactory.init();
PeerFactory.init();
Network.init();
Message.init();
Iterator<Video> itv = Repository.getVideoIterator();
p2pOverlay = new ArrayList<Overlay>();
Servers = new ArrayList<Server>();
while (itv.hasNext()) {
p2pOverlay.add(OverlayFactory.genOverlay(itv.next()));
}
Peer tmp = PeerFactory.genPeer(null);
while (tmp != null) {
Output.printP2PEvent(
"Server"
+ tmp.getPeerID()
+ " created! Bandwidth:"
+ Utilities.displayDouble(tmp.getUploadBW()));
Servers.add((Server) tmp);
tmp = PeerFactory.genPeer(null);
}
}
@Test
public void testAddEventListener() throws Exception {
connect();
PeerEventListener listener = new AbstractPeerEventListener();
peer.addEventListener(listener);
assertTrue(peer.removeEventListener(listener));
assertFalse(peer.removeEventListener(listener));
}
// Override .toString method
public String toString() {
String s = "";
for (Peer peer : listOfPeers) {
s += peer.toString() + "\n";
}
return s;
}
// Check that inventory message containing blocks we want is processed correctly.
@Test
public void newBlock() throws Exception {
Block b1 = createFakeBlock(blockStore).block;
blockChain.add(b1);
final Block b2 = makeSolvedTestBlock(b1);
// Receive notification of a new block.
final InventoryMessage inv = new InventoryMessage(unitTestParams);
InventoryItem item = new InventoryItem(InventoryItem.Type.Block, b2.getHash());
inv.addItem(item);
final AtomicInteger newBlockMessagesReceived = new AtomicInteger(0);
connect();
// Round-trip a ping so that we never see the response verack if we attach too quick
pingAndWait(writeTarget);
peer.addEventListener(
new AbstractPeerEventListener() {
@Override
public synchronized Message onPreMessageReceived(Peer p, Message m) {
if (p != peer) fail.set(true);
if (m instanceof Pong) return m;
int newValue = newBlockMessagesReceived.incrementAndGet();
if (newValue == 1 && !inv.equals(m)) fail.set(true);
else if (newValue == 2 && !b2.equals(m)) fail.set(true);
else if (newValue > 3) fail.set(true);
return m;
}
@Override
public synchronized void onBlocksDownloaded(Peer p, Block block, int blocksLeft) {
int newValue = newBlockMessagesReceived.incrementAndGet();
if (newValue != 3
|| p != peer
|| !block.equals(b2)
|| blocksLeft != OTHER_PEER_CHAIN_HEIGHT - 2) fail.set(true);
}
},
Threading.SAME_THREAD);
long height = peer.getBestHeight();
inbound(writeTarget, inv);
pingAndWait(writeTarget);
assertEquals(height + 1, peer.getBestHeight());
// Response to the getdata message.
inbound(writeTarget, b2);
pingAndWait(writeTarget);
Threading.waitForUserCode();
pingAndWait(writeTarget);
assertEquals(3, newBlockMessagesReceived.get());
GetDataMessage getdata = (GetDataMessage) outbound(writeTarget);
List<InventoryItem> items = getdata.getItems();
assertEquals(1, items.size());
assertEquals(b2.getHash(), items.get(0).hash);
assertEquals(InventoryItem.Type.Block, items.get(0).type);
}
@Override
public boolean execute() {
for (Integer nodeIndex = 0; nodeIndex < Network.size(); nodeIndex++) {
Long peerId = Network.get(nodeIndex).getID();
Peer peer = new Peer(peerId);
peer.calcualteGlobalDiv();
}
return false;
}
private void waitForAllToLock() {
for (Peer p : dec.getPeers()) {
while (!p.isLocked() && p.isConnected()) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
p.setLocked(false);
}
}
// Find Peer matching description
public Peer findPeer(String host, int port) {
Peer newPeer = new Peer(host, port);
for (Peer p : listOfPeers) {
if (newPeer.equals(p)) {
return p;
}
}
return null;
}
public Peer getReadyPeer() {
Peer p = getNextPeer();
while (!p.ready) {
p = getNextPeer();
}
p.ready = false;
return p;
}
public static void main(String args[])
throws IOException, InterruptedException, SharkProtocolNotSupportedException {
L.setLogLevel(L.LOGLEVEL_ALL);
Peer bob = new Peer("Bob", 7071);
// wait for alice 2 connect
Thread.sleep(10000);
// Thread.sleep(Integer.MAX_VALUE);
System.out.println("Shutting down Bob");
bob.stop();
}
private void waitPeerOpened() {
int i = 50;
while (i != 0) {
if (_peer.isOpen()) return;
try {
Thread.sleep(20);
} catch (InterruptedException e) {
}
i++;
}
assertTrue(_peer.isOpen());
}
public float getULRate() {
try {
float rate = 0.00f;
List<Peer> l = new LinkedList<Peer>(this.peerList.values());
for (Iterator it = l.iterator(); it.hasNext(); ) {
Peer p = (Peer) it.next();
if (p.getULRate(false) > 0) rate = rate + p.getULRate(true);
}
return rate / (1024 * 10);
} catch (Exception e) {
return 0.00f;
}
}
/*
* (non-Javadoc)
*
* @see net.jenet.protocol.Command#execute(org.Dizan
* Vasquez.jnet.Peer, net.jenet.protocol.Header)
*/
@Override
public Event execute(Host host, Peer peer, Header header) {
Event result = new Event();
Channel channel = peer.selectChannel(getHeader().getChannelID());
Packet packet;
if (channel == null || !peer.isConnected()) return result;
packet = new Packet(getHeader().getCommandLength() - byteSize(), 0);
packet.fromBuffer(host.getReceivedData());
peer.queueIncomingCommand(this, packet, 0);
return result;
}
@Test
public void fastCatchup() throws Exception {
connect();
// Check that blocks before the fast catchup point are retrieved using getheaders, and after
// using getblocks.
// This test is INCOMPLETE because it does not check we handle >2000 blocks correctly.
Block b1 = createFakeBlock(blockStore).block;
blockChain.add(b1);
Utils.rollMockClock(60 * 10); // 10 minutes later.
Block b2 = makeSolvedTestBlock(b1);
Utils.rollMockClock(60 * 10); // 10 minutes later.
Block b3 = makeSolvedTestBlock(b2);
Utils.rollMockClock(60 * 10);
Block b4 = makeSolvedTestBlock(b3);
// Request headers until the last 2 blocks.
peer.setDownloadParameters((Utils.now().getTime() / 1000) - (600 * 2) + 1, false);
peer.startBlockChainDownload();
GetHeadersMessage getheaders = (GetHeadersMessage) outbound(writeTarget);
List<Sha256Hash> expectedLocator = new ArrayList<Sha256Hash>();
expectedLocator.add(b1.getHash());
expectedLocator.add(unitTestParams.getGenesisBlock().getHash());
assertEquals(getheaders.getLocator(), expectedLocator);
assertEquals(getheaders.getStopHash(), Sha256Hash.ZERO_HASH);
// Now send all the headers.
HeadersMessage headers =
new HeadersMessage(
unitTestParams, b2.cloneAsHeader(), b3.cloneAsHeader(), b4.cloneAsHeader());
// We expect to be asked for b3 and b4 again, but this time, with a body.
expectedLocator.clear();
expectedLocator.add(b2.getHash());
expectedLocator.add(b1.getHash());
expectedLocator.add(unitTestParams.getGenesisBlock().getHash());
inbound(writeTarget, headers);
GetBlocksMessage getblocks = (GetBlocksMessage) outbound(writeTarget);
assertEquals(expectedLocator, getblocks.getLocator());
assertEquals(Sha256Hash.ZERO_HASH, getblocks.getStopHash());
// We're supposed to get an inv here.
InventoryMessage inv = new InventoryMessage(unitTestParams);
inv.addItem(new InventoryItem(InventoryItem.Type.Block, b3.getHash()));
inbound(writeTarget, inv);
GetDataMessage getdata = (GetDataMessage) outbound(writeTarget);
assertEquals(b3.getHash(), getdata.getItems().get(0).hash);
// All done.
inbound(writeTarget, b3);
pingAndWait(writeTarget);
closePeer(peer);
}
/**
* Given the list in parameter, check if the peers are already present in the peer list. If not,
* then add them and create a new task for them
*
* @param list LinkedHashMap
*/
public synchronized void updatePeerList(LinkedHashMap list) {
// this.lastUnchoking = System.currentTimeMillis();
synchronized (this.task) {
// this.peerList.putAll(list);
Set keyset = list.keySet();
for (Iterator i = keyset.iterator(); i.hasNext(); ) {
String key = (String) i.next();
if (!this.task.containsKey(key)) {
Peer p = (Peer) list.get(key);
this.peerList.put(p.toString(), p);
this.connect(p);
}
}
}
System.out.println("Peer List updated from tracker with " + list.size() + " peers");
}
@Test
public void getLargeBlock() throws Exception {
connect();
Block b1 = createFakeBlock(blockStore).block;
blockChain.add(b1);
Block b2 = makeSolvedTestBlock(b1);
Transaction t = new Transaction(unitTestParams);
t.addInput(b1.getTransactions().get(0).getOutput(0));
t.addOutput(
new TransactionOutput(
unitTestParams, t, BigInteger.ZERO, new byte[Block.MAX_BLOCK_SIZE - 1000]));
b2.addTransaction(t);
// Request the block.
Future<Block> resultFuture = peer.getBlock(b2.getHash());
assertFalse(resultFuture.isDone());
// Peer asks for it.
GetDataMessage message = (GetDataMessage) outbound(writeTarget);
assertEquals(message.getItems().get(0).hash, b2.getHash());
assertFalse(resultFuture.isDone());
// Peer receives it.
inbound(writeTarget, b2);
Block b = resultFuture.get();
assertEquals(b, b2);
}
@Override
public Session<Address, X> openSession(Send<X> send) throws InterruptedException, IOException {
if (send == null) return null;
Session<Address, Bytestring> s = p.openSession(new UnmarshallSend(send));
if (s == null) return null;
return new MarshallSession(s);
}
private void verifyGemFireSetup(final Peer manager) {
manager.run(
new SerializableRunnable(
"Verifies the GemFire Cluster was properly configured and initialized!") {
@Override
public void run() {
final ManagementService managementService =
ManagementService.getExistingManagementService(getCache());
WaitCriterion waitOnManagerCriterion =
new WaitCriterion() {
@Override
public boolean done() {
ManagerMXBean managerBean = managementService.getManagerMXBean();
DistributedRegionMXBean usersRegionBean =
managementService.getDistributedRegionMXBean(
getRegionPath(USERS_REGION_NAME));
return !(managerBean == null || usersRegionBean == null);
}
@Override
public String description() {
return String.format(
"Probing for the GemFire Manager '%1$s' and '%2$s' Region MXBeans...",
manager.getName(), USERS_REGION_NAME);
}
};
DistributedTestCase.waitForCriterion(waitOnManagerCriterion, 30000, 2000, true);
}
});
}
@Test
public void disconnectOldVersions1() throws Exception {
// Set up the connection with an old version.
final SettableFuture<Void> connectedFuture = SettableFuture.create();
final SettableFuture<Void> disconnectedFuture = SettableFuture.create();
peer.addEventListener(
new AbstractPeerEventListener() {
@Override
public void onPeerConnected(Peer peer, int peerCount) {
connectedFuture.set(null);
}
@Override
public void onPeerDisconnected(Peer peer, int peerCount) {
disconnectedFuture.set(null);
}
});
connectWithVersion(500);
// We must wait uninterruptibly here because connect[WithVersion] generates a peer that
// interrupts the current
// thread when it disconnects.
Uninterruptibles.getUninterruptibly(connectedFuture);
Uninterruptibles.getUninterruptibly(disconnectedFuture);
try {
peer.writeTarget.writeBytes(new byte[1]);
fail();
} catch (IOException e) {
assertTrue(
(e.getCause() != null && e.getCause() instanceof CancelledKeyException)
|| (e instanceof SocketException && e.getMessage().equals("Socket is closed")));
}
}
@Test
public void testTimeout() throws Throwable {
// Log.getLog().setDebugEnabled(true);
TestDiameterHandler serverHandler =
new TestDiameterHandler() {
@Override
public void doHandle(DiameterMessage message) throws Throwable {
Thread.sleep(300);
((DiameterServletRequest) message).createAnswer(Common.DIAMETER_SUCCESS).send();
}
};
_server.setHandler(serverHandler);
_server.start();
TestDiameterHandler clientHandler =
new TestDiameterHandler() {
@Override
public void doHandle(DiameterMessage message) throws Throwable {}
};
_client.setHandler(clientHandler);
_client.setRequestTimeout(200);
_client.start();
waitPeerOpened();
newUdr().send();
assertEquals(1, clientHandler.waitNoAnswer());
serverHandler.assertDone();
Thread.sleep(150);
clientHandler.assertDone(0);
assertTrue(_peer.isOpen());
}
public synchronized void disconnect(Peer p) {
DownloadTask dt = task.remove(p.toString());
if (dt != null) {
dt.end();
dt = null;
}
}
@Before
public void setUp() throws Exception {
// Log.getLog().setDebugEnabled(true);
_client = new Node(38681);
_client.getConnectors()[0].setHost("127.0.0.1");
_client.setIdentity("client");
_peer = new Peer("server");
_peer.setAddress(InetAddress.getByName("127.0.0.1"));
_peer.setPort(38680);
_client.addPeer(_peer);
_server = new Node(38680);
_server.getConnectors()[0].setHost("127.0.0.1");
_server.setIdentity("server");
}
// Remove peer
public void removePeer(Peer p) {
for (int i = 0; i < listOfPeers.size(); i++) {
if (p.equals(listOfPeers.get(i))) {
listOfPeers.remove(i);
}
}
}
public void buildData() {
Peer peer;
int size = peerList.size();
data = null;
data = new Object[size][6];
for (int i = 0; i < size; i++) {
peer = peerList.get(i);
data[i][0] = peer.getName();
data[i][1] = String.valueOf(peer.getPonderations().getPonderation(PeerActionKill.class));
data[i][2] = String.valueOf(peer.getPonderations().getPonderation(PeerActionAvg.class));
data[i][3] = String.valueOf(peer.getPonderations().getPonderation(PeerActionTalk.class));
data[i][4] = String.valueOf(peer.getPonderations().getPonderation(PeerActionQuery.class));
data[i][5] = String.valueOf(peer.getPonderations().getPonderation(PeerActionMove.class));
}
fireTableChanged(new TableModelEvent(this));
}
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
data[rowIndex][columnIndex] = aValue;
Peer p = peerList.get(rowIndex);
Class c;
if (columnIndex == 1) c = PeerActionKill.class;
else if (columnIndex == 2) c = PeerActionAvg.class;
else if (columnIndex == 3) c = PeerActionTalk.class;
else if (columnIndex == 4) c = PeerActionQuery.class;
else if (columnIndex == 5) c = PeerActionMove.class;
else c = PeerActionQuery.class;
p.getPonderations().setPonderation(c, Integer.parseInt(aValue.toString()));
fireTableCellUpdated(rowIndex, columnIndex);
}
