Examples of net.tomp2p.p2p.Peer

net.tomp2p.p2p.Peer
This is the main class to start DHT operations. This class makes use of the build pattern and for each DHT operation, a builder class is returned. The main operations can be initiated with {@link #put(Number160)}, {@link #get(Number160)}, {@link #add(Number160)}, {@link #addTracker(Number160)}, {@link #getTracker(Number160)}, {@link #remove(Number160)}, {@link #submit(Number160,Worker)}, {@link #send(Number160)}, {@link #sendDirect()}, {@link #broadcast(Number160)}. Each of those operations return a builder that offers more options. One of the main difference to a "regular" DHT is that TomP2P can store a map (key-values) instead of just values. To distinguish those, the keys are termed location key (for finding the right peer in the network), and content key (to store more than one value on a peer). For the put builder e.g. the following options can be set:
- {@link PutBuilder#setData(Number160,net.tomp2p.storage.Data)} - puts a content key with a value
- {@link PutBuilder#dataMap(Map) - puts multiple content key / values at once
- {@link PutBuilder#setPutIfAbsent() - only puts data if its not already on the peers
- ...
Furthermore, TomP2P also provides to store keys in different domains to avoid key collisions }( {@link PutBuilder#setDomainKey(Number160)).} @author Thomas Bocek

    p2.shutdown().awaitUninterruptibly();
  }


  @Test
  public void digestFromToTest() throws IOException, ClassNotFoundException {
    Peer p1 = new PeerMaker(Number160.createHash(1)).setEnableIndirectReplication(true).ports(5000)
        .makeAndListen();
    Peer p2 = new PeerMaker(Number160.createHash(2)).setEnableIndirectReplication(true).masterPeer(p1)
        .makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();


    String locationKey = "location";
    String contentKey = "content";


    List<H2HTestData> content = new ArrayList<H2HTestData>();
    int numberOfContent = 3;
    for (int i = 0; i < numberOfContent; i++) {
      H2HTestData data = new H2HTestData(NetworkTestUtil.randomString());
      data.generateVersionKey();
      if (i > 0) {
        data.setBasedOnKey(content.get(i - 1).getVersionKey());
      }
      content.add(data);


      p2.put(Number160.createHash(locationKey))
          .setData(Number160.createHash(contentKey), new Data(data))
          .setVersionKey(data.getVersionKey()).start().awaitUninterruptibly();
    }


    FutureDigest futureDigest = p1
        .digest(Number160.createHash(locationKey))
        .from(new Number640(Number160.createHash(locationKey), Number160.ZERO, Number160
            .createHash(contentKey), Number160.ZERO))
        .to(new Number640(Number160.createHash(locationKey), Number160.ZERO, Number160
            .createHash(contentKey), Number160.MAX_VALUE)).start();
    futureDigest.awaitUninterruptibly();


    assertEquals(numberOfContent, futureDigest.getDigest().keyDigest().size());


    for (H2HTestData data : content) {
      assertTrue(futureDigest
          .getDigest()
          .keyDigest()
          .containsKey(
              new Number640(Number160.createHash(locationKey), Number160.ZERO, Number160
                  .createHash(contentKey), data.getVersionKey())));
    }


    p1.shutdown().awaitUninterruptibly();
    p2.shutdown().awaitUninterruptibly();
  }

View Full Code Here

    p2.shutdown().awaitUninterruptibly();
  }


  @Test
  public void digestTest() throws IOException, ClassNotFoundException {
    Peer p1 = new PeerMaker(Number160.createHash(1)).setEnableIndirectReplication(true).ports(5000)
        .makeAndListen();
    Peer p2 = new PeerMaker(Number160.createHash(2)).setEnableIndirectReplication(true).masterPeer(p1)
        .makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();


    String locationKey = "location";
    String contentKey = "content";


    List<H2HTestData> content = new ArrayList<H2HTestData>();
    int numberOfContent = 3;
    for (int i = 0; i < numberOfContent; i++) {
      H2HTestData data = new H2HTestData(NetworkTestUtil.randomString());
      data.generateVersionKey();
      if (i > 0) {
        data.setBasedOnKey(content.get(i - 1).getVersionKey());
      }
      content.add(data);


      p2.put(Number160.createHash(locationKey))
          .setData(Number160.createHash(contentKey), new Data(data))
          .setVersionKey(data.getVersionKey()).start().awaitUninterruptibly();
    }


    for (H2HTestData data : content) {
      FutureDigest future = p1.digest(Number160.createHash(locationKey)).setDomainKey(Number160.ZERO)
          .setContentKey(Number160.createHash(contentKey)).setVersionKey(data.getVersionKey())
          .start();
      future.awaitUninterruptibly();


      assertEquals(1, future.getDigest().keyDigest().size());
      assertEquals(
          new Number640(Number160.createHash(locationKey), Number160.ZERO,
              Number160.createHash(contentKey), data.getVersionKey()), future.getDigest()
              .keyDigest().firstKey());
    }


    p1.shutdown().awaitUninterruptibly();
    p2.shutdown().awaitUninterruptibly();
  }

View Full Code Here

    p2.shutdown().awaitUninterruptibly();
  }


  @Test
  public void putTest() throws IOException, ClassNotFoundException {
    Peer p1 = new PeerMaker(Number160.createHash(1)).setEnableIndirectReplication(true).ports(5000)
        .makeAndListen();
    Peer p2 = new PeerMaker(Number160.createHash(2)).setEnableIndirectReplication(true).masterPeer(p1)
        .makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();


    String locationKey = "location";
    String contentKey = "content";


    H2HTestData data = new H2HTestData(NetworkTestUtil.randomString());
    data.generateVersionKey();
    // data.setBasedOnKey(Number160.createHash(10));


    p2.put(Number160.createHash(locationKey)).setData(Number160.createHash(contentKey), new Data(data))
        .setVersionKey(data.getVersionKey()).start().awaitUninterruptibly();


    FutureGet futureGet = p2.get(Number160.createHash(locationKey))
        .setContentKey(Number160.createHash(contentKey)).setVersionKey(data.getVersionKey()).start();
    futureGet.awaitUninterruptibly();


    assertNotNull(futureGet.getData());


    p1.shutdown().awaitUninterruptibly();
    p2.shutdown().awaitUninterruptibly();
  }

View Full Code Here

    clientConfig.signatureFactory(factory);
    ChannelServerConficuration serverConfig = PeerMaker.createDefaultChannelServerConfiguration();
    serverConfig.signatureFactory(factory);


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4834).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).channelClientConfiguration(clientConfig)
        .channelServerConfiguration(serverConfig).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).channelClientConfiguration(clientConfig)
        .channelServerConfiguration(serverConfig).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair1 = gen.generateKeyPair();
    KeyPair keyPair2 = gen.generateKeyPair();


    Number160 lKey = Number160.createHash("location");
    Number160 dKey = Number160.createHash("domain");
    Number160 cKey = Number160.createHash("content");
    Number160 vKey = Number160.createHash("version");
    Number160 bKey = Number160.createHash("based on");
    int ttl = 10;


    // initial put with data signature and entry protection
    Data data = new Data("data1").setProtectedEntry();
    data.ttlSeconds(ttl).basedOn(bKey).sign(keyPair1, factory);
    // put using content protection key 1 to sign message
    FuturePut futureIntialPut = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futureIntialPut.awaitUninterruptibly();
    Assert.assertTrue(futureIntialPut.isSuccess());


    // verify put
    Data retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify data signature
    Assert.assertTrue(retData.verify(keyPair1.getPublic(), factory));


    // change data signature to keys 2 using same data, sign with new key 2
    data = new Data("data1").ttlSeconds(ttl).setProtectedEntry().sign(keyPair2, factory);
    // change content protection keys to keys 2
    // data.publicKey(keyPair2.getPublic()); is already done with data.sign(...)
    // create meta data
    data.duplicateMeta();
    // put meta using content content protection key 1 to sign message
    FuturePut futurePutMeta = p1.put(lKey).setDomainKey(dKey).putMeta().setData(cKey, data)
        .setVersionKey(vKey).keyPair(keyPair1).start();
    futurePutMeta.awaitUninterruptibly();
    Assert.assertTrue(futurePutMeta.isSuccess());


    // verify change
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    // verify new content protection keys 2
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    // verify new data signature
    Assert.assertTrue(retData.verify(keyPair2.getPublic(), factory));


    // try overwrite with content protection key 1 and data signature (expected to fail)
    data = new Data("data2").setProtectedEntry();
    data.ttlSeconds(ttl).basedOn(bKey).sign(keyPair2, factory);
    // put using content wrong protection keys 1 to sign message
    FuturePut futureOverwrite3 = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futureOverwrite3.awaitUninterruptibly();
    Assert.assertFalse(futureOverwrite3.isSuccess());


    // verify that nothing changed
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    // verify not changed signature
    Assert.assertTrue(retData.verify(keyPair2.getPublic(), factory));


    p1.shutdown().awaitUninterruptibly();
    p2.shutdown().awaitUninterruptibly();
  }

View Full Code Here

    clientConfig.signatureFactory(factory);
    ChannelServerConficuration serverConfig = PeerMaker.createDefaultChannelServerConfiguration();
    serverConfig.signatureFactory(factory);


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4834).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).channelClientConfiguration(clientConfig)
        .channelServerConfiguration(serverConfig).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).channelClientConfiguration(clientConfig)
        .channelServerConfiguration(serverConfig).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair1 = gen.generateKeyPair();
    KeyPair keyPair2 = gen.generateKeyPair();


    Number160 lKey = Number160.createHash("location");
    Number160 dKey = Number160.createHash("domain");
    Number160 cKey = Number160.createHash("content");
    Number160 vKey = Number160.createHash("version");
    Number160 bKey = Number160.createHash("based on");
    int ttl = 10;


    // initial put with data signature and entry protection
    Data data = new Data("data1").setProtectedEntry();
    data.ttlSeconds(ttl).basedOn(bKey).sign(keyPair1, factory);
    // put using content protection key 1 to sign message
    FuturePut futureIntialPut = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futureIntialPut.awaitUninterruptibly();
    Assert.assertTrue(futureIntialPut.isSuccess());


    // verify put
    Data retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    // verify content protection keys 1 is set
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify data signature
    Assert.assertTrue(retData.verify(keyPair1.getPublic(), factory));


    // create signature with keys 1 having the data object
    byte[] signature1 = factory.sign(keyPair1.getPrivate(), data.buffer()).encode();


    // decrypt signature to get hash of the object
    Cipher rsa = Cipher.getInstance("RSA");
    rsa.init(Cipher.DECRYPT_MODE, keyPair1.getPublic());
    byte[] hash = rsa.doFinal(signature1);


    // encrypt hash with new key pair to get the new signature (without having the data object)
    rsa = Cipher.getInstance("RSA");
    rsa.init(Cipher.ENCRYPT_MODE, keyPair2.getPrivate());
    byte[] signatureNew = rsa.doFinal(hash);


    // change data signature to keys 2, assign the reused hash from signature
    data = new Data().ttlSeconds(ttl).signature(codec.decode(signatureNew)).setProtectedEntry();
    // don't forget to set signed flag
    data.signed(true);
    // change the content protection keys to 2
    data.publicKey(keyPair2.getPublic());
    // create meta data
    data.duplicateMeta();
    // put meta using content content protection key 1 to sign message
    FuturePut futurePutMeta = p1.put(lKey).setDomainKey(dKey).putMeta().setData(cKey, data)
        .setVersionKey(vKey).keyPair(keyPair1).start();
    futurePutMeta.awaitUninterruptibly();
    Assert.assertTrue(futurePutMeta.isSuccess());


    // verify change
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    // verify change to content protection keys 2
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    // verify new data signature
    Assert.assertTrue(retData.verify(keyPair2.getPublic(), factory));


    // try overwrite with content protection key 1 and data signature (exptected to fail)
    data = new Data("data2").setProtectedEntry();
    data.ttlSeconds(ttl).basedOn(bKey).sign(keyPair2, factory);
    // put using content wrong protection keys 1 to sign message
    FuturePut futureOverwrite3 = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futureOverwrite3.awaitUninterruptibly();
    Assert.assertFalse(futureOverwrite3.isSuccess());


    // verify that nothing changed
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    // verify not changed signature
    Assert.assertTrue(retData.verify(keyPair2.getPublic(), factory));


    p1.shutdown().awaitUninterruptibly();
    p2.shutdown().awaitUninterruptibly();
  }

View Full Code Here

      ClassNotFoundException, InvalidKeyException, SignatureException, NoSuchPaddingException,
      IllegalBlockSizeException, BadPaddingException {
    KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4834).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair1 = gen.generateKeyPair();
    KeyPair keyPair2 = gen.generateKeyPair();


    Number160 lKey = Number160.createHash("location");
    Number160 dKey = Number160.createHash("domain");
    Number160 cKey = Number160.createHash("content");


    // put version 1 with protection keys 1
    Data data1 = new Data("data1").setProtectedEntry();
    Number160 vKey1 = Number160.ZERO;
    FuturePut futurePut1 = p1.put(lKey).setData(cKey, data1).setDomainKey(dKey).setVersionKey(vKey1)
        .keyPair(keyPair1).start();
    futurePut1.awaitUninterruptibly();
    assertTrue(futurePut1.isSuccess());


    // verify put of version 1
    Data retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    // verify content protection keys 1 is set
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    
    // try to overwrite version 1 without protection keys (expected to fail)
    Data data1A = new Data("data1A");
    FuturePut futurePut1A = p1.put(lKey).setData(cKey, data1A).setDomainKey(dKey).setVersionKey(vKey1)
        .start();
    futurePut1A.awaitUninterruptibly();
    assertFalse(futurePut1A.isSuccess());


    // verify that nothing changed
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());


    // try to overwrite version 1 with wrong protection keys 2 (expected to fail)
    Data data1B = new Data("data1B").setProtectedEntry();
    FuturePut futurePut1B = p1.put(lKey).setData(cKey, data1B).setDomainKey(dKey).setVersionKey(vKey1)
        .keyPair(keyPair2).start();
    futurePut1B.awaitUninterruptibly();
    assertFalse(futurePut1B.isSuccess());


    // verify that nothing changed
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());


    // overwrite version 1 with protection keys 1
    Data data1Overwrite = new Data("data1Overwrite").setProtectedEntry();
    FuturePut futurePutOverwrite = p1.put(lKey).setData(cKey, data1Overwrite).setDomainKey(dKey)
        .setVersionKey(vKey1).keyPair(keyPair1).start();
    futurePutOverwrite.awaitUninterruptibly();
    assertTrue(futurePutOverwrite.isSuccess());


    // verify overwrite
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1Overwrite", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());


    // try to put new version 2 (basing on version 1) with wrong protection keys 2 (expected to fail)
    Data data2 = new Data("data2").basedOn(vKey1).setProtectedEntry();
    // version 2 takes new version key
    Number160 vKey2 = Number160.createHash("version2");
    FuturePut futurePut2 = p1.put(lKey).setData(cKey, data2).setDomainKey(dKey).setVersionKey(vKey2)
        .keyPair(keyPair2).start();
    futurePut2.awaitUninterruptibly();
    assertFalse(futurePut2.isSuccess());


    // verify no put of version 2
    assertNull(p2.get(lKey).setContentKey(cKey).setVersionKey(vKey2).setDomainKey(dKey).start()
        .awaitUninterruptibly().getData());


    // put new version 3 (basing on version 1) with correct protection keys 1
    Data data3 = new Data("data3").basedOn(vKey1).setProtectedEntry();
    Number160 vKey3 = Number160.createHash("version3");
    FuturePut futurePut3 = p1.put(lKey).setData(cKey, data3).setDomainKey(dKey).setVersionKey(vKey3)
        .keyPair(keyPair1).start();
    futurePut3.awaitUninterruptibly();
    assertTrue(futurePut3.isSuccess());


    // verify put of version 3
    assertEquals("data3",
        (String) p2.get(lKey).setContentKey(cKey).setVersionKey(vKey3).setDomainKey(dKey).start()
            .awaitUninterruptibly().getData().object());
    
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey3).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data3", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());


    // try to put a version X in version key range of version 1 and 3 with wrong protection keys 2
    // (expected to fail)
    Data dataX = new Data("dataX").setProtectedEntry();
    Number160 vKeyX = Number160.createHash("versionX");
    FuturePut futurePut4 = p1.put(lKey).setData(cKey, dataX).setDomainKey(dKey).setVersionKey(vKeyX)
        .keyPair(keyPair2).start();
    futurePut4.awaitUninterruptibly();
    assertFalse(futurePut4.isSuccess());


    // verify no put of version X
    assertNull(p2.get(lKey).setContentKey(cKey).setVersionKey(vKeyX).setDomainKey(dKey).start()
        .awaitUninterruptibly().getData());


    // try to put random version Y in version key range of version 1 and 3 without protection keys
    // (expected to fail)
    Data dataY = new Data("dataY").setProtectedEntry();
    Number160 vKeyY = Number160.createHash("versionX");
    futurePut4 = p1.put(lKey).setData(cKey, dataY).setDomainKey(dKey).setVersionKey(vKeyY).start();
    futurePut4.awaitUninterruptibly();
    assertFalse(futurePut4.isSuccess());


    // verify no put of version Y
    assertNull(p2.get(lKey).setContentKey(cKey).setVersionKey(vKeyY).setDomainKey(dKey).start()
        .awaitUninterruptibly().getData());


    p1.shutdown().awaitUninterruptibly();
    p2.shutdown().awaitUninterruptibly();
  }

View Full Code Here

      IOException, ClassNotFoundException, InvalidKeyException, SignatureException,
      NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
    KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4834).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair1 = gen.generateKeyPair();
    KeyPair keyPair2 = gen.generateKeyPair();


    Number160 lKey = Number160.createHash("location");
    Number160 dKey = Number160.createHash("domain");
    Number160 cKey = Number160.createHash("content");


    // put version 1 with protection keys 1
    Data data1 = new Data("data1").setProtectedEntry();
    Number160 vKey1 = Number160.ZERO;
    FuturePut futurePut1 = p1.put(lKey).setData(cKey, data1).setDomainKey(dKey).setVersionKey(vKey1)
        .keyPair(keyPair1).start();
    futurePut1.awaitUninterruptibly();
    assertTrue(futurePut1.isSuccess());


    // put new version 2 (basing on version 1) with protection keys 1
    Data data2 = new Data("data2").basedOn(vKey1).setProtectedEntry();
    // version 2 takes new version key
    Number160 vKey2 = Number160.createHash("version2");
    FuturePut futurePut2 = p1.put(lKey).setData(cKey, data2).setDomainKey(dKey).setVersionKey(vKey2)
        .keyPair(keyPair1).start();
    futurePut2.awaitUninterruptibly();
    assertTrue(futurePut2.isSuccess());


    // change protection key on version 1 with a put meta
    Data dataMeta = new Data().setProtectedEntry().publicKey(keyPair2.getPublic()).duplicateMeta();
    // use the old protection key 1 to sign the message
    FuturePut futurePutMeta = p1.put(lKey).setDomainKey(dKey).setVersionKey(vKey1).putMeta()
        .setData(cKey, dataMeta).keyPair(keyPair1).start();
    futurePutMeta.awaitUninterruptibly();
    assertTrue(futurePutMeta.isSuccess());


    // verify change at version 1
    Data retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    // verify change of content protection keys to 2
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    
    // verify change at version 2
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey2).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data2", (String) retData.object());
    // verify change of content protection keys to 2
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());    // <==== is keypair1 but should be keypair2


    // overwrite version 1 with protection keys 2
    Data data1Overwrite = new Data("data1Overwrite").setProtectedEntry();
    FuturePut futurePut1Overwrite = p1.put(lKey).setData(cKey, data1Overwrite).setDomainKey(dKey)
        .setVersionKey(vKey1).keyPair(keyPair2).start();
    futurePut1Overwrite.awaitUninterruptibly();
    assertTrue(futurePut1Overwrite.isSuccess());
    
    // verify overwrite version 1
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1Overwrite", (String) retData.object());
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());


    // overwrite version 2 with protection keys 2
    Data data2Overwrite = new Data("data2Overwrite").setProtectedEntry();
    FuturePut futurePut2Overwrite = p1.put(lKey).setData(cKey, data2Overwrite).setDomainKey(dKey)
        .setVersionKey(vKey2).keyPair(keyPair2).start();
    futurePut2Overwrite.awaitUninterruptibly();
    assertTrue(futurePut2Overwrite.isSuccess());


    // verify overwrite version 2
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey2).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data2Overwrite", (String) retData.object());
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    
    // put new version 3 (basing on version 2) with protection keys 2
    Data data3 = new Data("data3").basedOn(vKey2).setProtectedEntry();
    Number160 vKey3 = Number160.createHash("version3");
    FuturePut futurePut3 = p1.put(lKey).setData(cKey, data3).setDomainKey(dKey).setVersionKey(vKey3)
        .keyPair(keyPair2).start();
    futurePut3.awaitUninterruptibly();
    assertTrue(futurePut3.isSuccess());
    
    // verify put version 3
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey3).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data3", (String) retData.object());
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());


    // try to put a version X in version key range of version 1, 2 and 3 with wrong protection keys 1
    // (expected to fail)
    Data dataX = new Data("dataX").setProtectedEntry();
    Number160 vKeyX = Number160.createHash("versionX");
    FuturePut futurePut4 = p1.put(lKey).setData(cKey, dataX).setDomainKey(dKey).setVersionKey(vKeyX)
        .keyPair(keyPair1).start();
    futurePut4.awaitUninterruptibly();
    assertFalse(futurePut4.isSuccess());


    // verify no put of version X
    assertNull(p2.get(lKey).setContentKey(cKey).setVersionKey(vKeyX).setDomainKey(dKey).start()
        .awaitUninterruptibly().getData());


    // try to put random version Y in version key range of version 1, 2 and 3 without protection keys
    // (expected to fail)
    Data dataY = new Data("dataY").setProtectedEntry();
    Number160 vKeyY = Number160.createHash("versionX");
    futurePut4 = p1.put(lKey).setData(cKey, dataY).setDomainKey(dKey).setVersionKey(vKeyY).start();
    futurePut4.awaitUninterruptibly();
    assertFalse(futurePut4.isSuccess());


    // verify no put of version Y
    assertNull(p2.get(lKey).setContentKey(cKey).setVersionKey(vKeyY).setDomainKey(dKey).start()
        .awaitUninterruptibly().getData());


    p1.shutdown().awaitUninterruptibly();
    p2.shutdown().awaitUninterruptibly();
  }

View Full Code Here

  public void testTTLDecrement() throws IOException, ClassNotFoundException, NoSuchAlgorithmException,
      InvalidKeyException, SignatureException, InterruptedException {
    KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4834).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).storageIntervalMillis(1).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).storageIntervalMillis(1).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair1 = gen.generateKeyPair();


    Number160 lKey = Number160.createHash("location");
    Number160 dKey = Number160.createHash("domain");
    Number160 cKey = Number160.createHash("content");
    Number160 vKey = Number160.createHash("version");
    Number160 bKey = Number160.ZERO;


    int ttl = 4;


    String testData = "data";
    Data data = new Data(testData).setProtectedEntry();
    data.ttlSeconds(ttl).basedOn(bKey);


    // initial put
    FuturePut futurePut = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futurePut.awaitUninterruptibly();
    Assert.assertTrue(futurePut.isSuccess());


    // wait a moment, so that the ttl decrements
    Thread.sleep(2000);


    // check decrement of ttl through a normal get
    FutureGet futureGet = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start();
    futureGet.awaitUninterruptibly();
    Assert.assertTrue(futureGet.isSuccess());
    Assert.assertTrue(ttl > futureGet.getData().ttlSeconds());


    // check decrement of ttl through a get meta
    FutureDigest futureDigest = p1.digest(lKey).setDomainKey(dKey).setContentKey(cKey)
        .setVersionKey(vKey).returnMetaValues().start();
    futureDigest.awaitUninterruptibly();
    Assert.assertTrue(futureDigest.isSuccess());
    Data dataMeta = futureDigest.getDigest().dataMap().values().iterator().next();
    Assert.assertTrue(ttl > dataMeta.ttlSeconds());


    // wait again a moment, till data gets expired
    Thread.sleep(2000);


    // check if data has been removed
    Data retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertNull(retData);


    p1.shutdown().awaitUninterruptibly();
    p2.shutdown().awaitUninterruptibly();
  }

View Full Code Here

    beforeClass();
  }


  @Test
  public void testReplicationPureTomP2P() throws IOException, InterruptedException {
    Peer p1 = new PeerMaker(Number160.createHash(1)).setEnableIndirectReplication(true).ports(5000)
        .makeAndListen();
    Peer p2 = new PeerMaker(Number160.createHash(2)).setEnableIndirectReplication(true).masterPeer(p1)
        .makeAndListen();
    Peer p3 = new PeerMaker(Number160.createHash(3)).setEnableIndirectReplication(true).masterPeer(p1)
        .makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();


    FuturePut putFuture = p2.put(Number160.createHash("key"))
        .setData(Number160.ZERO, Number160.ZERO, new Data("test")).start();
    putFuture.awaitUninterruptibly();
    putFuture.getFutureRequests().awaitUninterruptibly();
    Assert.assertEquals(2, putFuture.getFutureRequests().getSuccessCounter());


    p3.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();


    H2HWaiter w = new H2HWaiter(10);
    Data tmp = null;
    do {
      w.tickASecond();
      tmp = p3.getPeerBean()
          .storage()
          .get(new Number640(Number160.createHash("key"), Number160.ZERO, Number160.ZERO,
              Number160.ZERO));
    } while (tmp == null);


    Assert.assertNotNull(tmp);


    p1.shutdown();
    p2.shutdown();
    p3.shutdown();
  }

View Full Code Here

  public void testPutOverwriteWithoutContentProtectionKeys() throws IOException, ClassNotFoundException,
      NoSuchAlgorithmException, InvalidKeyException, SignatureException {
    KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4838).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair = gen.generateKeyPair();


    Number160 lKey = Number160.createHash("location");
    Number160 dKey = Number160.createHash("domain");
    Number160 cKey = Number160.createHash("content");


    String testData = "data";
    Data data = new Data(testData).setProtectedEntry();


    // put with protection key
    FuturePut futurePut1 = p1.put(lKey).setData(cKey, data).setDomainKey(dKey).keyPair(keyPair).start();
    futurePut1.awaitUninterruptibly();
    assertTrue(futurePut1.isSuccess());


    // verify put from peer 1
    FutureGet futureGet1a = p1.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet1a.awaitUninterruptibly();
    assertTrue(futureGet1a.isSuccess());
    Data retData = futureGet1a.getData();
    assertEquals(testData, (String) retData.object());
    assertEquals(keyPair.getPublic(), retData.publicKey());


    // verify put from peer 2
    FutureGet futureGet1b = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet1b.awaitUninterruptibly();
    assertTrue(futureGet1b.isSuccess());
    retData = futureGet1b.getData();
    assertEquals(testData, (String) retData.object());
    assertEquals(keyPair.getPublic(), retData.publicKey());


    // try a put without a protection key (through peer 2)
    Data data2 = new Data("data2");
    FuturePut futurePut2 = p2.put(lKey).setData(cKey, data2).setDomainKey(dKey).start();
    futurePut2.awaitUninterruptibly();
    assertFalse(futurePut2.isSuccess());


    // verify that nothing changed from peer 1
    FutureGet futureGet2a = p1.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet2a.awaitUninterruptibly();
    assertTrue(futureGet2a.isSuccess());
    retData = futureGet2a.getData();
    // should have been not modified
    assertEquals(testData, (String) retData.object());
    assertEquals(keyPair.getPublic(), retData.publicKey());


    // verify that nothing changed from peer 2
    FutureGet futureGet2b = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet2b.awaitUninterruptibly();
    assertTrue(futureGet2b.isSuccess());
    retData = futureGet2b.getData();
    // should have been not modified
    assertEquals(testData, (String) retData.object());
    assertEquals(keyPair.getPublic(), retData.publicKey());


    // overwrite
    String newTestData = "new data";
    data = new Data(newTestData).setProtectedEntry();
    // sign put message with protection keys
    FuturePut futurePut4 = p1.put(lKey).setData(cKey, data).keyPair(keyPair).setDomainKey(dKey).start();
    futurePut4.awaitUninterruptibly();
    Assert.assertTrue(futurePut4.isSuccess());


    // verify overwrite from peer 1
    FutureGet futureGet4a = p1.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet4a.awaitUninterruptibly();
    assertTrue(futureGet4a.isSuccess());
    retData = futureGet4a.getData();
    assertEquals(keyPair.getPublic(), retData.publicKey());
    // should have been modified
    assertEquals(newTestData, (String) retData.object());


    // verify overwrite from peer 2
    FutureGet futureGet4b = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet4b.awaitUninterruptibly();
    assertTrue(futureGet4b.isSuccess());
    retData = futureGet4b.getData();
    assertEquals(keyPair.getPublic(), retData.publicKey());
    // should have been modified
    assertEquals(newTestData, (String) retData.object());


    p1.shutdown().awaitUninterruptibly();
    p2.shutdown().awaitUninterruptibly();
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of net.tomp2p.p2p.Peer

lupos.distributed.p2p.network.impl.TomP2P

net.tomp2p.connection.ChannelCreator

net.tomp2p.connection.PeerConnection

net.tomp2p.dht.TestAddUpdateTTL

net.tomp2p.dht.TestDHT

net.tomp2p.dht.TestRealNetwork

net.tomp2p.dht.TestSend

net.tomp2p.dht.UtilsDHT2

net.tomp2p.examples.ExampleDiscover

net.tomp2p.examples.ExampleDST

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.