A connection of a Node accepts and fills all received Root objects. It's possible to DoS a Node sending big amount of Root objects to a Node, but don't send related data.

RPC of the Node has no protection. And anyone can "administrate" the Node.

Package node/gnet has internal mapping stringifyed_address -> connection_instance. But a network address can be represented many ways. For example, "[::]:9090" and "[::1]:9090" are equal. Thus, methods like gnet.Pool.Connection(address string) *gnet.Conn and similar methods of node package can cause unexpected results.

goalng-nuts question

The CXO should works on go1.8.3 up to tip. For the CI. https://travis-ci.org/skycoin/cxo

I could see such a mechanism powering basically a global network file store. I.e. something really really useful. It could come with replication controls so that the owner can choose the desired replication (paying whatever the rate is for the amount of data that results). Pay more to have more guarantee that the data won't be lost, etc. In this manner skycoin could not only be asset-backed by bandwidth capacity but also asset-backed by storage capacity.

Sometimes the RefByHash returns error instead of element.

We need a way to get preview of a feed. E.g. a Root object of a feed, we are not subscribed, filled partially (some branches by choose).

Gopkg.lock and Gopkg.toml are in the .gitignore, was there a specific reason for that?

1. UDP transport will be removed.
2. TCP transport will be merged into Node.

Hence, RPC implementation has to be refactored. It must contain only two public objects:

1. RPC - rpc server, based on net/rpc.
2. RPCClient - rpc client, based on net/rpc.

There is no need to split methods of RPCClient into 3 separate groups, like RootRPC, NodeRPC
and TransportRPC.

Note, that net/rpc is frozen.

OnRootFilled callback triggers (from receiving a filled root). Which is fine.

However, the root object has member IsFull set as false, even though it is filled.

Ha-ha

Detailed statistic required:

• create time of Root objects
• access time of Root object
• total amount and size of related objects
  • exclusive
  • shared
• same for a feed
• total objects
• total size

This statistic will be used for cleaning (#97)

The xorm drops (*xorm.Rows).Next() error and (*xorm.Rows).Err() can only returns sql.ErrNoRows. Since, CXO have a little SLQ work, then I think CXO should rid out of the xorm to

• avoid unnecessary dependency
• handle possible error

The work is faster then time of waiting reply from xorm developers.

Work: 50% (in progress, next after #147)
Test: 0%

Node's networking resources must be managed properly:

• Number of outgoing connections must be limited.
• Number of pending connections must be limited.
• Overall number of connections must be limited.

There is a bug that not allows to use user provided names for schemas. Everything is ok, until you are using structures in structures. For example

type User struct {}

type TwoUsers struct {
    User
    AnotherUser User
}

and if

reg := skyobejct.NewRegistry()
reg.Register("User", User{})
reg.Register("TwoUsers", TwoUsers{})

then everything is ok, but if

reg := skyobejct.NewRegistry()
reg.Register("bbs.User", User{})
reg.Register("bbs.TwoUsers", TwoUsers{})

then it fails.

A node can have stale Root objects and potential memory leaks. Thus we have to track connections from which a Root object we send to subscribers received until the Root is filled up.

1. split skyobject package, moving schemas, registries, and references to subpackage.
2. all usrInterface, err := Value() to err = Value(&usr)
3. Refs: rid out of RefsElem
4. a little changes in Root references API.

A feed should be split by heads. A Root should have descriptor.

Add in memory cache for the CXDS database to speed up the CXO.

Implement networking via gnet instead of net package.

See #152 #151 #155

gnet is TCP-only, hence:

• UDP transport of Node has to be removed.
• As there is no more need to distinguish between UDP transport and TCP transport, the last can be renamed to Transport.
• As Transport has only one method, which is actually called by user code, it can be merged completely to Node.

Peer discovery must be implemented by application, built on top of CXO, hence:

• Discovery servers, based on gnet must be removed.
• Unfinished implementation of PEX must be removed.

Application, which uses CXO, has to implement application-specific wrapper on top of Node and Conn. That wrapper must include implementation of peer discovery (via PEX, DHT, tracking servers or any other mechanism).

See https://github.com/skycoin/skycoin/pull/1259/files for how

Improve GC.

By default a node calls GC every 5 seconds and removes all root objects of every feed before
last full root object.Thus, if root objects appears often than replicates, then them never be replicated.

Proposals how the GC should work to handle all needs are welcome.

Temporary workaround is: disable GC and call it manually.

The data package represents database and keeps all inside.
We need to split it for two separate packages:

1. key-value store with API

• get []byte by hash
• set hash-[]byte pair
• increment refs count of an object by hash
• decrement the refs count

While the refs count is zero, object should be deleted. This part will be moved to server later

2. machine local index DB that keeps meta information for every object

• the size of value

• when key was created
• the number of accesses
• last access time
• ref count

Index DB uses little-endian encoding of seq numbers. This way Root objects grater then 256 can't be used.

Move to new gotree API to avoid dep ensure for end users (to make CXO go gettable, without additional movements).

Work: 100%
Tests: 10% (work in progress).

Implement connection state machine. Connections can be in one of the following states:

• pending
• connected
• introduced.

Distinguish between incoming and outgoing connections.

Use implementation from Skycoin node.

A way to avoid mutual connections required.

Required:

• node must keep published Root until it replicated by remote peer
• node must keep "unpacked" Root objects until pack.Close called if the pack contains saved Root object or object it contains refers to saved Root
• node must send 'drop' and 'approve' messages to peers from which a Root object comes from
• node must decrement refs. count of all saved (only saved not all related!) dropping Root

There has been an abundance of "root not found" errors popping up. It happens when I connect two cxo daemons together. I would expect that one daemon will be fully aware of the roots available on the other daemon? Or is this not the case?