예제 #1
0
func TestPacketSignature(t *testing.T) {
	packet := Packet{
		Dst:     utils.NewRandomNodeID(utils.GlobalNamespace),
		Src:     utils.NewRandomNodeID(utils.GlobalNamespace),
		Type:    "dht",
		Payload: []byte("payload"),
	}

	key := utils.GeneratePrivateKey()
	packet.Sign(key)

	if !packet.Verify(&key.PublicKey) {
		t.Errorf("varification failed")
	}
}
예제 #2
0
파일: dht_test.go 프로젝트: h2so5/murcott
func TestDhtGroup(t *testing.T) {
	logger := log.NewLogger()

	n := 20
	dhtmap := make(map[string]*DHT)
	idary := make([]utils.NodeInfo, n)

	for i := 0; i < n; i++ {
		id := utils.NewRandomNodeID(namespace)
		addr, err := utp.ResolveAddr("utp", ":0")
		if err != nil {
			t.Fatal(err)
		}
		utp, err := utp.Listen("utp", addr)
		uaddr, err := getLoopbackAddr(utp.Addr())
		if err != nil {
			t.Fatal(err)
		}
		node := utils.NodeInfo{ID: id, Addr: uaddr}
		d := NewDHT(10, node.ID, node.ID, utp.RawConn, logger)
		idary[i] = node
		dhtmap[id.String()] = d
		defer d.Close()

		go func() {
			var b [102400]byte
			for {
				l, addr, err := utp.RawConn.ReadFrom(b[:])
				if err != nil {
					return
				}
				d.ProcessPacket(b[:l], addr)
			}
		}()
	}

	rootNode := idary[0]
	rootDht := dhtmap[rootNode.ID.String()]

	for _, d := range dhtmap {
		d.AddNode(rootNode)
		d.FindNearestNode(d.id)
	}

	kvs := map[string]string{}
	for i := 0; i < 20; i++ {
		kvs[fmt.Sprintf("<%d>", i)] = utils.NewRandomNodeID(namespace).String()
	}

	for k, v := range kvs {
		rootDht.StoreValue(k, v)
	}

	for _, d := range dhtmap {
		for k := range kvs {
			val := d.LoadValue(k)
			if val == nil {
				t.Errorf("key not found: %s", k)
			} else if *val != kvs[k] {
				t.Errorf("wrong value for the key: %s : %s; %s expected", k, val, kvs[k])
			}
		}
	}
}
예제 #3
0
파일: dht_test.go 프로젝트: h2so5/murcott
func TestDhtPing(t *testing.T) {

	addr, err := utp.ResolveAddr("utp", ":0")
	if err != nil {
		t.Fatal(err)
	}
	utp1, err := utp.Listen("utp", addr)
	if err != nil {
		t.Fatal(err)
	}
	utp2, err := utp.Listen("utp", addr)
	if err != nil {
		t.Fatal(err)
	}

	addr1, err := getLoopbackAddr(utp1.Addr())
	if err != nil {
		t.Fatal(err)
	}
	addr2, err := getLoopbackAddr(utp2.Addr())
	if err != nil {
		t.Fatal(err)
	}

	node1 := utils.NodeInfo{ID: utils.NewRandomNodeID(namespace), Addr: addr1}
	node2 := utils.NodeInfo{ID: utils.NewRandomNodeID(namespace), Addr: addr2}

	dht1 := NewDHT(10, node1.ID, node1.ID, utp1.RawConn, log.NewLogger())
	dht2 := NewDHT(10, node2.ID, node2.ID, utp2.RawConn, log.NewLogger())
	defer dht1.Close()
	defer dht2.Close()

	go func() {
		var b [102400]byte
		for {
			l, addr, err := utp1.RawConn.ReadFrom(b[:])
			if err != nil {
				return
			}
			dht1.ProcessPacket(b[:l], addr)
		}
	}()

	go func() {
		var b [102400]byte
		for {
			l, addr, err := utp2.RawConn.ReadFrom(b[:])
			if err != nil {
				return
			}
			dht2.ProcessPacket(b[:l], addr)
		}
	}()

	dht1.AddNode(node2)

	time.Sleep(time.Millisecond * 100)

	if dht1.GetNodeInfo(node2.ID) == nil {
		t.Errorf("dht1 should know node2")
	}

	if dht2.GetNodeInfo(node1.ID) == nil {
		t.Errorf("dht2 should know node1")
	}
}