Long term project. Must be on Linux or OSX. Must have experience with golang.
Must have good english.
Follow installation instructions
- do `cd skycoin/cmd` then `go run ./skycoin/skycoin.go`
- send me screenshot of the application running
This imports and uses the modules in
- runs an instance of "nodemanager"
- starts a webserver (skycoin/src/mesh/gui/) that will expose a JSON API
For example of what this is doing, run
1. Clean up skycoin/src/mesh. The code is a mess and I want to delete stuff and trim it down
2. Add golang functions to nodemanager
NodeManager in skycoin/src/mesh/nodemanager, manages a list of nodes
- A node's id is a public key (skycoin.cipher)
- a node has a list of transports (connections between nodes)
- a route is a multihop connection, across multiple nodes (A -> B -> C), if data is dropped into a route on A, it will arrive at C
The Node Manager needs a clean golang API for
- creating nodes, deleting nodes
- getting a list of nodes
- adding a transport to a node
- removing a transport from a node
- getting information about a transport (how many KB/s it is using, total bandwidth used in each direction)
- adding a route, removing a route, getting information about a route (hops in each direction)
Then we need to wrap the golang API, with a JSON API
- the json API will go in skycoin/src/gui
- the webserver is already setup and can be run with skycoin/cmd/mesh/
- skycoin/src/mesh/node should be simplified or rewritten (remove packet fragmentation, make it simpler
- skycoin/src/transport, this is a point to point connection between nodes. We need to move message retransmission here. When a packet is sent over a transport, the other side should send an ACK back. The ACK should go to the transport, not the node.
- a node is identified by a 33 byte public key
- a network adapter has "transports" or connections (UDP right now). Which are point-to-point connections between nodes.
- All messages are length, prefixed byte arrays (4 bytes for length, then data)
- the node manager should manage network adapters (UDP socket) and allow new transports to be started up or added. Each transport should have a status (connected, no connected, attempting, etc). Packets are passed up to the NodeManager, to be sent on a physical network connection.
- a route is a multihop forwarding rule. When a packet comes in for a route, we look up in a table and forward it to the next node.
- We need to be able to start a service on a node, then have another node create a route to the service and send and receiving messages. We need a connection struct, that acts like a packet. The connection struct should fragment larger packets into small packets and they should be reassembled on the other side. We assume a maximum packet size (512 bytes) for the internal network.
- the transport, needs to confirm packets, with an ACK packet. It should stores a buffer of messages and retransmit them until they have been confirmed.
The code is a mess and needs to be cleaned up and simplified. We will do a series of small, incremental changes and clean up the code.