Example #1
0
func TestGivePeersMessage(t *testing.T) {
	d := newDefaultDaemon()
	defer shutdown(d)
	addrs := []string{addr, addrb, "7"}
	peers := make([]*pex.Peer, 3)
	for i, addr := range addrs {
		peers[i] = &pex.Peer{Addr: addr}
	}
	m := NewGivePeersMessage(peers)
	assert.Equal(t, len(m.GetPeers()), 2)
	testSimpleMessageHandler(t, d, m)
	assert.Equal(t, m.GetPeers()[0], addrs[0])
	assert.Equal(t, m.GetPeers()[1], addrs[1])

	// Test disabled
	d.Peers.Config.Disabled = true
	m.Process(d)
	assert.Equal(t, len(d.Peers.Peers.Peerlist), 0)

	// Test serialization
	m = NewGivePeersMessage(peers)
	b := encoder.Serialize(m)
	m2 := GivePeersMessage{}
	assert.Nil(t, encoder.DeserializeRaw(b, &m2))
	assert.Equal(t, *m, m2)

	// Peers should be added to the pex when processed
	d.Peers.Config.Disabled = false
	m.Process(d)
	assert.Equal(t, len(d.Peers.Peers.Peerlist), 2)
	gnet.EraseMessages()
}
Example #2
0
func TransactionDeserialize(b []byte) Transaction {
	t := Transaction{}
	if err := encoder.DeserializeRaw(b, &t); err != nil {
		log.Panic("Failed to deserialize transaction")
	}
	return t
}
Example #3
0
func TestPingMessage(t *testing.T) {
	d := newDefaultDaemon()
	defer shutdown(d)
	p := d.Pool.Pool
	m := &PingMessage{}
	testSimpleMessageHandler(t, d, m)

	m.c = messageContext(addr)
	go p.ConnectionWriteLoop(m.c.Conn)
	defer m.c.Conn.Close()
	assert.NotPanics(t, func() { m.Process(d) })
	// A pong message should have been sent
	wait()
	assert.Equal(t, len(p.SendResults), 1)
	if len(p.SendResults) == 0 {
		t.Fatalf("SendResults empty, would block")
	}
	sr := <-p.SendResults
	assert.Equal(t, sr.Connection, m.c.Conn)
	assert.Nil(t, sr.Error)
	_, ok := sr.Message.(*PongMessage)
	assert.True(t, ok)
	assert.False(t, m.c.Conn.LastSent.IsZero())

	// Test serialization
	mm := PingMessage{}
	b := encoder.Serialize(mm)
	m2 := PingMessage{}
	assert.Nil(t, encoder.DeserializeRaw(b, &m2))
	assert.Equal(t, mm, m2)

	gnet.EraseMessages()
}
Example #4
0
//decode block to bytes
func Dec_block(b []byte) (SignedBlock, error) {
	if len(b) < 16 {
		log.Panic()
	}

	var dln uint64 = le_Uint64(b[0:8])
	var seq uint64 = le_Uint64(b[8:16])
	var chk uint64 = le_Uint64(b[16:24])

	if dln != uint64(len(b)) {
		log.Panic("Dec_block, length check failed")
	}

	b = b[24:] //cleave off header

	if chk != FnvsHash(b) {
		log.Panic("Dec_block, checksum failed")
	}

	var sb SignedBlock
	err := encoder.DeserializeRaw(b, &sb)
	if err != nil {
		log.Panic("Dec_block, deserialization failed")
	}

	if seq != sb.Block.Head.BkSeq {
		log.Panic("Dec_block, seq mismatch")
	}

	return sb, nil
}
Example #5
0
func TestGetPeersMessage(t *testing.T) {
	d := newDefaultDaemon()
	defer shutdown(d)
	p := d.Pool
	m := NewGetPeersMessage()
	testSimpleMessageHandler(t, d, m)
	d.Peers.Peers.AddPeer(addr)
	q, err := d.Peers.Peers.AddPeer(addrb)
	assert.Nil(t, err)
	q.Private = true
	d.Peers.Config.ReplyCount = 100
	m.c = messageContext(addr)

	// Peers disabled
	d.Peers.Config.Disabled = true
	assert.NotPanics(t, func() { m.Process(d) })
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 0)
	assert.True(t, m.c.Conn.LastSent.IsZero())

	// Peers enabled
	d.Peers.Config.Disabled = false
	m.c = messageContext(addr)
	defer m.c.Conn.Close()
	go p.Pool.ConnectionWriteLoop(m.c.Conn)
	assert.NotPanics(t, func() { m.Process(d) })
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 1)
	if len(p.Pool.SendResults) == 0 {
		t.Fatal("SendResults empty, would block")
	}
	sr := <-p.Pool.SendResults
	assert.Nil(t, sr.Error)
	assert.Equal(t, sr.Connection, m.c.Conn)
	msg, ok := sr.Message.(*GivePeersMessage)
	assert.True(t, ok)
	// Private peer should not be included
	ipAddr, err := NewIPAddr(addr)
	assert.Nil(t, err)
	assert.Equal(t, msg.Peers, []IPAddr{ipAddr})
	assert.False(t, m.c.Conn.LastSent.IsZero())

	// If no peers, nothing should happen
	m.c.Conn.LastSent = util.ZeroTime()
	delete(d.Peers.Peers.Peerlist, addr)
	assert.NotPanics(t, func() { m.Process(d) })
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 0)
	assert.True(t, m.c.Conn.LastSent.IsZero())

	// Test serialization
	m = NewGetPeersMessage()
	b := encoder.Serialize(m)
	m2 := GetPeersMessage{}
	assert.Nil(t, encoder.DeserializeRaw(b, &m2))
	assert.Equal(t, *m, m2)

	gnet.EraseMessages()
}
Example #6
0
func (bt *BlockTree) getBlock(hash cipher.SHA256) *coin.Block {
	bin := bt.blocks.Get(hash[:])
	if bin == nil {
		return nil
	}
	block := coin.Block{}
	if err := encoder.DeserializeRaw(bin, &block); err != nil {
		return nil
	}
	return &block
}
Example #7
0
func getBucketValue(db *bolt.DB, name []byte, key []byte, value interface{}) error {
	return db.View(func(tx *bolt.Tx) error {
		b := tx.Bucket(name)
		bin := b.Get(key)
		if bin == nil {
			value = nil
			return nil
		}
		return encoder.DeserializeRaw(bin, value)
	})
}
Example #8
0
// Get returns signature of specific block
func (bs BlockSigs) Get(hash cipher.SHA256) (cipher.Sig, error) {
	bin := bs.Sigs.Get(hash[:])
	if bin == nil {
		return cipher.Sig{}, fmt.Errorf("no sig for %v", hash.Hex())
	}
	var sig cipher.Sig
	if err := encoder.DeserializeRaw(bin, &sig); err != nil {
		return cipher.Sig{}, err
	}
	return sig, nil
}
Example #9
0
// Get return nil on not found.
func (au *addressUx) Get(address cipher.Address) ([]cipher.SHA256, error) {
	uxHashes := []cipher.SHA256{}
	bin := au.bkt.Get(address.Bytes())
	if bin == nil {
		return nil, nil
	}
	if err := encoder.DeserializeRaw(bin, &uxHashes); err != nil {
		return nil, err
	}
	return uxHashes, nil
}
Example #10
0
func (bt *BlockTree) getHashInDepth(depth uint64, filter func(ps []coin.HashPair) cipher.SHA256) (cipher.SHA256, error) {
	key := itob(depth)
	pairsBin := bt.tree.Get(key)
	pairs := []coin.HashPair{}
	if err := encoder.DeserializeRaw(pairsBin, &pairs); err != nil {
		return cipher.SHA256{}, err
	}

	hash := filter(pairs)
	return hash, nil
}
Example #11
0
func LoadSerializedBlockchain(filename string) (*SerializedBlockchain, error) {
	sbc := &SerializedBlockchain{}
	data, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}
	err = encoder.DeserializeRaw(data, sbc)
	if err != nil {
		return nil, err
	}
	return sbc, nil
}
Example #12
0
func TestIntroductionMessageHandle(t *testing.T) {
	d := newDefaultDaemon()
	defer shutdown(d)
	mc := messageContext(addr)
	m := NewIntroductionMessage(d.Messages.Mirror, d.Config.Version,
		d.Pool.Pool.Config.Port)

	// Test valid handling
	m.Mirror = d.Messages.Mirror + 1
	err := m.Handle(mc, d)
	assert.Nil(t, err)
	if len(d.messageEvents) == 0 {
		t.Fatalf("messageEvent is empty")
	}
	<-d.messageEvents
	assert.True(t, m.valid)
	m.valid = false

	// Test matching mirror
	m.Mirror = d.Messages.Mirror
	err = m.Handle(mc, d)
	assert.Equal(t, err, DisconnectSelf)
	m.Mirror = d.Messages.Mirror + 1
	assert.False(t, m.valid)

	// Test mismatched d.Config.Version
	m.Version = d.Config.Version + 1
	err = m.Handle(mc, d)
	assert.Equal(t, err, DisconnectInvalidVersion)
	assert.False(t, m.valid)

	// Test serialization
	m = NewIntroductionMessage(d.Messages.Mirror, d.Config.Version,
		d.Pool.Pool.Config.Port)
	b := encoder.Serialize(m)
	m2 := IntroductionMessage{}
	assert.Nil(t, encoder.DeserializeRaw(b, &m2))
	assert.Equal(t, *m, m2)

	// Test already connected
	d.mirrorConnections[m.Mirror] = make(map[string]uint16)
	d.mirrorConnections[m.Mirror][addrIP] = addrPort + 1
	err = m.Handle(mc, d)
	assert.Equal(t, err, DisconnectConnectedTwice)
	delete(d.mirrorConnections, m.Mirror)
	assert.False(t, m.valid)

	for len(d.messageEvents) > 0 {
		<-d.messageEvents
	}
	gnet.EraseMessages()
}
Example #13
0
// GetAllBlockHashInDepth returns all block hash of N depth in the tree.
func (bt *BlockTree) GetAllBlockHashInDepth(depth uint64) ([]cipher.SHA256, error) {
	key := itob(depth)
	pairsBin := bt.tree.Get(key)
	pairs := []coin.HashPair{}
	if err := encoder.DeserializeRaw(pairsBin, &pairs); err != nil {
		return []cipher.SHA256{}, err
	}
	hashes := make([]cipher.SHA256, len(pairs))
	for i, hp := range pairs {
		hashes[i] = hp.Hash
	}
	return hashes, nil
}
Example #14
0
func TestGetBlocksMessageHandle(t *testing.T) {
	d := newDefaultDaemon()
	defer shutdown(d)
	m := NewGetBlocksMessage(uint64(1))
	assert.Equal(t, m.LastBlock, uint64(1))
	testSimpleMessageHandler(t, d, m)

	// Test serialization
	m = NewGetBlocksMessage(uint64(106))
	b := encoder.Serialize(m)
	m2 := GetBlocksMessage{}
	assert.Nil(t, encoder.DeserializeRaw(b, &m2))
	assert.Equal(t, *m, m2)
}
Example #15
0
// Get get transaction by tx hash, return nil on not found.
func (txs transactions) Get(hash cipher.SHA256) (*Transaction, error) {
	bin := txs.bkt.Get(hash[:])
	if bin == nil {
		return nil, nil
	}

	// deserialize tx
	var tx Transaction
	if err := encoder.DeserializeRaw(bin, &tx); err != nil {
		return nil, err
	}

	return &tx, nil
}
Example #16
0
func TestPongMessage(t *testing.T) {
	cmsgs := NewMessagesConfig()
	cmsgs.Register()
	m := &PongMessage{}
	// Pongs dont do anything
	assert.Nil(t, m.Handle(messageContext(addr), nil))
	gnet.EraseMessages()

	// Test serialization
	mm := PongMessage{}
	b := encoder.Serialize(mm)
	m2 := PongMessage{}
	assert.Nil(t, encoder.DeserializeRaw(b, &m2))
	assert.Equal(t, mm, m2)

}
Example #17
0
func getHashPairInDepth(tree *bolt.Bucket, dep uint64, fn func(hp coin.HashPair) bool) ([]coin.HashPair, error) {
	v := tree.Get(itob(dep))
	if v == nil {
		return []coin.HashPair{}, nil
	}

	hps := []coin.HashPair{}
	if err := encoder.DeserializeRaw(v, &hps); err != nil {
		return nil, err
	}
	pairs := []coin.HashPair{}
	for _, ps := range hps {
		if fn(ps) {
			pairs = append(pairs, ps)
		}
	}
	return pairs, nil
}
Example #18
0
func TestGiveBlocksMessageHandle(t *testing.T) {
	d := newDefaultDaemon()
	defer shutdown(d)
	_, mv := setupVisor()
	blocks := []visor.SignedBlock{mv.GetGenesisBlock()}
	m := NewGiveBlocksMessage(blocks)
	assert.Equal(t, m.Blocks, blocks)
	testSimpleMessageHandler(t, d, m)

	// Test serialization
	bks, err := makeBlocks(mv, 4)
	assert.Nil(t, err)
	blocks = append(blocks, bks...)
	m = NewGiveBlocksMessage(blocks)
	b := encoder.Serialize(m)
	m2 := GiveBlocksMessage{}
	assert.Nil(t, encoder.DeserializeRaw(b, &m2))
	assert.Equal(t, *m, m2)
}
Example #19
0
func LoadBlockSigs(filename string) (BlockSigs, error) {
	bs := NewBlockSigs()
	data, err := ioutil.ReadFile(filename)
	if err != nil {
		return bs, err
	}
	sigs := BlockSigsSerialized{make([]BlockSigSerialized, 0)}
	err = encoder.DeserializeRaw(data, &sigs)
	if err != nil {
		return bs, err
	}
	bs.Sigs = make(map[uint64]cipher.Sig, len(sigs.Sigs))
	for _, s := range sigs.Sigs {
		bs.Sigs[s.BkSeq] = s.Sig
		if s.BkSeq > bs.MaxSeq {
			bs.MaxSeq = s.BkSeq
		}
	}
	return bs, nil
}
Example #20
0
func TestAnnounceTxnsMessageHandle(t *testing.T) {
	d := newDefaultDaemon()
	defer shutdown(d)
	tx := createUnconfirmedTxn()
	txns := []cipher.SHA256{tx.Txn.Hash()}
	m := NewAnnounceTxnsMessage(txns)
	assert.Equal(t, m.Txns, txns)
	testSimpleMessageHandler(t, d, m)

	// Test serialization
	tx = createUnconfirmedTxn()
	txns = append(txns, tx.Txn.Hash())
	tx = createUnconfirmedTxn()
	txns = append(txns, tx.Txn.Hash())
	m = NewAnnounceTxnsMessage(txns)
	assert.Equal(t, len(m.Txns), 3)
	b := encoder.Serialize(m)
	m2 := AnnounceTxnsMessage{}
	assert.Nil(t, encoder.DeserializeRaw(b, &m2))
	assert.Equal(t, *m, m2)
}
Example #21
0
func TestGiveTxnsMessageHandle(t *testing.T) {
	d := newDefaultDaemon()
	defer shutdown(d)
	tx := createUnconfirmedTxn()
	txns := coin.Transactions{tx.Txn}
	m := NewGiveTxnsMessage(txns)
	assert.Equal(t, m.Txns, txns)
	testSimpleMessageHandler(t, d, m)

	// Test serialization
	tx = createUnconfirmedTxn()
	txns = append(txns, tx.Txn)
	tx = createUnconfirmedTxn()
	txns = append(txns, tx.Txn)
	m = NewGiveTxnsMessage(txns)
	assert.Equal(t, len(m.Txns), 3)
	b := encoder.Serialize(m)
	m2 := GiveTxnsMessage{}
	assert.Nil(t, encoder.DeserializeRaw(b, &m2))
	assert.Equal(t, *m, m2)
}
Example #22
0
//creates block from byte array
func BlockFromBytes(data []byte) (Block, error) {
	var b Block
	return b, encoder.DeserializeRaw(data, &b)
}