swarm: plan bee for content storage and distribution on web3
This change imports the Swarm protocol codebase. Compared to the 'swarm' branch, a few mostly cosmetic changes had to be made: * The various redundant log message prefixes are gone. * All files now have LGPLv3 license headers. * Minor code changes were needed to please go vet and make the tests pass on Windows. * Further changes were required to adapt to the go-ethereum develop branch and its new Go APIs. Some code has not (yet) been brought over: * swarm/cmd/bzzhash: will reappear as cmd/bzzhash later * swarm/cmd/bzzup.sh: will be reimplemented in cmd/bzzup * swarm/cmd/makegenesis: will reappear somehow * swarm/examples/album: will move to a separate repository * swarm/examples/filemanager: ditto * swarm/examples/files: will not be merged * swarm/test/*: will not be merged * swarm/services/swear: will reappear as contracts/swear when needed
This commit is contained in:
ΞTHΞЯSPHΞЯΞ
Felix Lange
317
swarm/network/messages.go
Normal file
317
swarm/network/messages.go
Normal file
@@ -0,0 +1,317 @@
|
||||
// Copyright 2016 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package network
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net"
|
||||
"time"
|
||||
|
||||
"github.com/ethereum/go-ethereum/contracts/chequebook"
|
||||
"github.com/ethereum/go-ethereum/p2p/discover"
|
||||
"github.com/ethereum/go-ethereum/swarm/network/kademlia"
|
||||
"github.com/ethereum/go-ethereum/swarm/services/swap"
|
||||
"github.com/ethereum/go-ethereum/swarm/storage"
|
||||
)
|
||||
|
||||
/*
|
||||
BZZ protocol Message Types and Message Data Types
|
||||
*/
|
||||
|
||||
// bzz protocol message codes
|
||||
const (
|
||||
statusMsg = iota // 0x01
|
||||
storeRequestMsg // 0x02
|
||||
retrieveRequestMsg // 0x03
|
||||
peersMsg // 0x04
|
||||
syncRequestMsg // 0x05
|
||||
deliveryRequestMsg // 0x06
|
||||
unsyncedKeysMsg // 0x07
|
||||
paymentMsg // 0x08
|
||||
)
|
||||
|
||||
/*
|
||||
Handshake
|
||||
|
||||
* Version: 8 byte integer version of the protocol
|
||||
* ID: arbitrary byte sequence client identifier human readable
|
||||
* Addr: the address advertised by the node, format similar to DEVp2p wire protocol
|
||||
* Swap: info for the swarm accounting protocol
|
||||
* NetworkID: 8 byte integer network identifier
|
||||
* Caps: swarm-specific capabilities, format identical to devp2p
|
||||
* SyncState: syncronisation state (db iterator key and address space etc) persisted about the peer
|
||||
|
||||
*/
|
||||
type statusMsgData struct {
|
||||
Version uint64
|
||||
ID string
|
||||
Addr *peerAddr
|
||||
Swap *swap.SwapProfile
|
||||
NetworkId uint64
|
||||
}
|
||||
|
||||
func (self *statusMsgData) String() string {
|
||||
return fmt.Sprintf("Status: Version: %v, ID: %v, Addr: %v, Swap: %v, NetworkId: %v", self.Version, self.ID, self.Addr, self.Swap, self.NetworkId)
|
||||
}
|
||||
|
||||
/*
|
||||
store requests are forwarded to the peers in their kademlia proximity bin
|
||||
if they are distant
|
||||
if they are within our storage radius or have any incentive to store it
|
||||
then attach your nodeID to the metadata
|
||||
if the storage request is sufficiently close (within our proxLimit, i. e., the
|
||||
last row of the routing table)
|
||||
*/
|
||||
type storeRequestMsgData struct {
|
||||
Key storage.Key // hash of datasize | data
|
||||
SData []byte // the actual chunk Data
|
||||
// optional
|
||||
Id uint64 // request ID. if delivery, the ID is retrieve request ID
|
||||
requestTimeout *time.Time // expiry for forwarding - [not serialised][not currently used]
|
||||
storageTimeout *time.Time // expiry of content - [not serialised][not currently used]
|
||||
from *peer // [not serialised] protocol registers the requester
|
||||
}
|
||||
|
||||
func (self storeRequestMsgData) String() string {
|
||||
var from string
|
||||
if self.from == nil {
|
||||
from = "self"
|
||||
} else {
|
||||
from = self.from.Addr().String()
|
||||
}
|
||||
end := len(self.SData)
|
||||
if len(self.SData) > 10 {
|
||||
end = 10
|
||||
}
|
||||
return fmt.Sprintf("from: %v, Key: %v; ID: %v, requestTimeout: %v, storageTimeout: %v, SData %x", from, self.Key, self.Id, self.requestTimeout, self.storageTimeout, self.SData[:end])
|
||||
}
|
||||
|
||||
/*
|
||||
Retrieve request
|
||||
|
||||
Timeout in milliseconds. Note that zero timeout retrieval requests do not request forwarding, but prompt for a peers message response. therefore they serve also
|
||||
as messages to retrieve peers.
|
||||
|
||||
MaxSize specifies the maximum size that the peer will accept. This is useful in
|
||||
particular if we allow storage and delivery of multichunk payload representing
|
||||
the entire or partial subtree unfolding from the requested root key.
|
||||
So when only interested in limited part of a stream (infinite trees) or only
|
||||
testing chunk availability etc etc, we can indicate it by limiting the size here.
|
||||
|
||||
Request ID can be newly generated or kept from the request originator.
|
||||
If request ID Is missing or zero, the request is handled as a lookup only
|
||||
prompting a peers response but not launching a search. Lookup requests are meant
|
||||
to be used to bootstrap kademlia tables.
|
||||
|
||||
In the special case that the key is the zero value as well, the remote peer's
|
||||
address is assumed (the message is to be handled as a self lookup request).
|
||||
The response is a PeersMsg with the peers in the kademlia proximity bin
|
||||
corresponding to the address.
|
||||
*/
|
||||
|
||||
type retrieveRequestMsgData struct {
|
||||
Key storage.Key // target Key address of chunk to be retrieved
|
||||
Id uint64 // request id, request is a lookup if missing or zero
|
||||
MaxSize uint64 // maximum size of delivery accepted
|
||||
MaxPeers uint64 // maximum number of peers returned
|
||||
Timeout uint64 // the longest time we are expecting a response
|
||||
timeout *time.Time // [not serialied]
|
||||
from *peer //
|
||||
}
|
||||
|
||||
func (self retrieveRequestMsgData) String() string {
|
||||
var from string
|
||||
if self.from == nil {
|
||||
from = "ourselves"
|
||||
} else {
|
||||
from = self.from.Addr().String()
|
||||
}
|
||||
var target []byte
|
||||
if len(self.Key) > 3 {
|
||||
target = self.Key[:4]
|
||||
}
|
||||
return fmt.Sprintf("from: %v, Key: %x; ID: %v, MaxSize: %v, MaxPeers: %d", from, target, self.Id, self.MaxSize, self.MaxPeers)
|
||||
}
|
||||
|
||||
// lookups are encoded by missing request ID
|
||||
func (self retrieveRequestMsgData) isLookup() bool {
|
||||
return self.Id == 0
|
||||
}
|
||||
|
||||
// sets timeout fields
|
||||
func (self retrieveRequestMsgData) setTimeout(t *time.Time) {
|
||||
self.timeout = t
|
||||
if t != nil {
|
||||
self.Timeout = uint64(t.UnixNano())
|
||||
} else {
|
||||
self.Timeout = 0
|
||||
}
|
||||
}
|
||||
|
||||
func (self retrieveRequestMsgData) getTimeout() (t *time.Time) {
|
||||
if self.Timeout > 0 && self.timeout == nil {
|
||||
timeout := time.Unix(int64(self.Timeout), 0)
|
||||
t = &timeout
|
||||
self.timeout = t
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// peerAddr is sent in StatusMsg as part of the handshake
|
||||
type peerAddr struct {
|
||||
IP net.IP
|
||||
Port uint16
|
||||
ID []byte // the 64 byte NodeID (ECDSA Public Key)
|
||||
Addr kademlia.Address
|
||||
}
|
||||
|
||||
// peerAddr pretty prints as enode
|
||||
func (self peerAddr) String() string {
|
||||
var nodeid discover.NodeID
|
||||
copy(nodeid[:], self.ID)
|
||||
return discover.NewNode(nodeid, self.IP, 0, self.Port).String()
|
||||
}
|
||||
|
||||
/*
|
||||
peers Msg is one response to retrieval; it is always encouraged after a retrieval
|
||||
request to respond with a list of peers in the same kademlia proximity bin.
|
||||
The encoding of a peer is identical to that in the devp2p base protocol peers
|
||||
messages: [IP, Port, NodeID]
|
||||
note that a node's DPA address is not the NodeID but the hash of the NodeID.
|
||||
|
||||
Timeout serves to indicate whether the responder is forwarding the query within
|
||||
the timeout or not.
|
||||
|
||||
NodeID serves as the owner of payment contracts and signer of proofs of transfer.
|
||||
|
||||
The Key is the target (if response to a retrieval request) or missing (zero value)
|
||||
peers address (hash of NodeID) if retrieval request was a self lookup.
|
||||
|
||||
Peers message is requested by retrieval requests with a missing or zero value request ID
|
||||
*/
|
||||
type peersMsgData struct {
|
||||
Peers []*peerAddr //
|
||||
Timeout uint64 //
|
||||
timeout *time.Time // indicate whether responder is expected to deliver content
|
||||
Key storage.Key // present if a response to a retrieval request
|
||||
Id uint64 // present if a response to a retrieval request
|
||||
from *peer
|
||||
}
|
||||
|
||||
// peers msg pretty printer
|
||||
func (self peersMsgData) String() string {
|
||||
var from string
|
||||
if self.from == nil {
|
||||
from = "ourselves"
|
||||
} else {
|
||||
from = self.from.Addr().String()
|
||||
}
|
||||
var target []byte
|
||||
if len(self.Key) > 3 {
|
||||
target = self.Key[:4]
|
||||
}
|
||||
return fmt.Sprintf("from: %v, Key: %x; ID: %v, Peers: %v", from, target, self.Id, self.Peers)
|
||||
}
|
||||
|
||||
func (self peersMsgData) setTimeout(t *time.Time) {
|
||||
self.timeout = t
|
||||
if t != nil {
|
||||
self.Timeout = uint64(t.UnixNano())
|
||||
} else {
|
||||
self.Timeout = 0
|
||||
}
|
||||
}
|
||||
|
||||
func (self peersMsgData) getTimeout() (t *time.Time) {
|
||||
if self.Timeout > 0 && self.timeout == nil {
|
||||
timeout := time.Unix(int64(self.Timeout), 0)
|
||||
t = &timeout
|
||||
self.timeout = t
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
/*
|
||||
syncRequest
|
||||
|
||||
is sent after the handshake to initiate syncing
|
||||
the syncState of the remote node is persisted in kaddb and set on the
|
||||
peer/protocol instance when the node is registered by hive as online{
|
||||
*/
|
||||
|
||||
type syncRequestMsgData struct {
|
||||
SyncState *syncState `rlp:"nil"`
|
||||
}
|
||||
|
||||
func (self *syncRequestMsgData) String() string {
|
||||
return fmt.Sprintf("%v", self.SyncState)
|
||||
}
|
||||
|
||||
/*
|
||||
deliveryRequest
|
||||
|
||||
is sent once a batch of sync keys is filtered. The ones not found are
|
||||
sent as a list of syncReuest (hash, priority) in the Deliver field.
|
||||
When the source receives the sync request it continues to iterate
|
||||
and fetch at most N items as yet unsynced.
|
||||
At the same time responds with deliveries of the items.
|
||||
*/
|
||||
type deliveryRequestMsgData struct {
|
||||
Deliver []*syncRequest
|
||||
}
|
||||
|
||||
func (self *deliveryRequestMsgData) String() string {
|
||||
return fmt.Sprintf("sync request for new chunks\ndelivery request for %v chunks", len(self.Deliver))
|
||||
}
|
||||
|
||||
/*
|
||||
unsyncedKeys
|
||||
|
||||
is sent first after the handshake if SyncState iterator brings up hundreds, thousands?
|
||||
and subsequently sent as a response to deliveryRequestMsgData.
|
||||
|
||||
Syncing is the iterative process of exchanging unsyncedKeys and deliveryRequestMsgs
|
||||
both ways.
|
||||
|
||||
State contains the sync state sent by the source. When the source receives the
|
||||
sync state it continues to iterate and fetch at most N items as yet unsynced.
|
||||
At the same time responds with deliveries of the items.
|
||||
*/
|
||||
type unsyncedKeysMsgData struct {
|
||||
Unsynced []*syncRequest
|
||||
State *syncState
|
||||
}
|
||||
|
||||
func (self *unsyncedKeysMsgData) String() string {
|
||||
return fmt.Sprintf("sync: keys of %d new chunks (state %v) => synced: %v", len(self.Unsynced), self.State, self.State.Synced)
|
||||
}
|
||||
|
||||
/*
|
||||
payment
|
||||
|
||||
is sent when the swap balance is tilted in favour of the remote peer
|
||||
and in absolute units exceeds the PayAt parameter in the remote peer's profile
|
||||
*/
|
||||
|
||||
type paymentMsgData struct {
|
||||
Units uint // units actually paid for (checked against amount by swap)
|
||||
Promise *chequebook.Cheque // payment with cheque
|
||||
}
|
||||
|
||||
func (self *paymentMsgData) String() string {
|
||||
return fmt.Sprintf("payment for %d units: %v", self.Units, self.Promise)
|
||||
}
|
||||
Reference in New Issue
Block a user