unistack-org/micro
4
0
Fork 2
Code Issues 18 Pull Requests Actions Packages Projects Releases 331 Wiki Activity

Some functioning network code

Browse Source
This commit is contained in:
Asim Aslam
2019-07-02 20:54:21 +01:00
parent c3611aead2
commit f619e46def
5 changed files with 487 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

313
network/node.go
View File

@@ -1,7 +1,11 @@
package network
import (
"errors"
"fmt"
"net"
"runtime/debug"
"strconv"
"sync"
"time"
@@ -9,6 +13,7 @@ import (
"github.com/micro/go-micro/codec/proto"
"github.com/micro/go-micro/registry"
"github.com/micro/go-micro/transport"
"github.com/micro/go-micro/util/addr"
"github.com/micro/go-micro/util/log"
pb "github.com/micro/go-micro/network/proto"
@@ -20,7 +25,7 @@ type node struct {
// closed channel
closed chan bool
mtx sync.RWMutex
sync.RWMutex
// the node id
id string
@@ -40,32 +45,46 @@ type node struct {
// leases for connections to us
// link id:link
links map[string]*link
// messages received over links
recv chan *Message
// messages received over links
send chan *Message
}
// network methods
func newNode(n *network) (*node, error) {
// create a new node
node := new(node)
// closed channel
node.closed = make(chan bool)
// set the nodes network
node.network = n
// initially we have no id
// create an id and address
// TODO: create a real unique id and address
// lease := n.lease()
// set the node id
// node.id = lease.Node.Id
node := &node{
// the links
links: make(map[string]*link),
// closed channel
closed: make(chan bool),
// set the nodes network
network: n,
// set the default transport
transport: transport.DefaultTransport,
// set the default registry
registry: registry.DefaultRegistry,
// receive channel for accepted connections
recv: make(chan *Message, 128),
// send channel for accepted connections
send: make(chan *Message, 128),
}
// get the transport we're going to use for our tunnels
// TODO: set to quic or tunnel or something else
t, ok := n.Options.Values().Get("network.transport")
if ok {
node.transport = t.(transport.Transport)
} else {
// TODO: set to quic
node.transport = transport.DefaultTransport
}
// register the node with the registry for the network
// TODO: use a registrar or something else for local things
r, ok := n.Options.Values().Get("network.registry")
if ok {
node.registry = r.(registry.Registry)
}
// we listen on a random address, this is not advertised
@@ -77,8 +96,6 @@ func newNode(n *network) (*node, error) {
// set the listener
node.listener = l
// TODO: this should be an overlay address
// ideally received via some dhcp style broadcast
node.address = l.Addr()
// TODO: start the router and broadcast advertisements
@@ -90,36 +107,51 @@ func newNode(n *network) (*node, error) {
// process any incoming messages on the listener
// this is our inbound network connection
node.accept(l)
go node.accept(l)
// register the node with the registry for the network
// TODO: use a registrar or something else for local things
r, ok := n.Options.Values().Get("network.registry")
if ok {
node.registry = r.(registry.Registry)
} else {
node.registry = registry.DefaultRegistry
}
// process any messages being sent by node.Send
// forwards to every link we have
go node.process()
// lookup the network to see if there's any nodes
records := n.lookup(node.registry)
// should we actually do this?
// assuming if there are no records, we are the first
// we set ourselves a lease. should we actually do this?
if len(records) == 0 {
// set your own node id
lease := n.lease()
node.id = lease.Node.Id
}
// register self with the network registry
var port int
// TODO: this should be an overlay address
// ideally received via some dhcp style broadcast
host, pp, err := net.SplitHostPort(l.Addr())
if err == nil {
pt, _ := strconv.Atoi(pp)
port = pt
}
// some horrible things are happening
if host == "::" {
host = ""
}
// set the address
addr, _ := addr.Extract(host)
node.address = fmt.Sprintf("%s:%d", addr, port)
// register self with the registry using network: prefix
// this is a local registry of nodes separate to the resolver
// maybe consolidate registry/resolver
// TODO: find a way to do this via gossip or something else
// TODO: find a way to do this via gossip or something like
// a registrar or tld or whatever
if err := node.registry.Register(&registry.Service{
// register with the network id
Name: "network:" + n.Id(),
Nodes: []*registry.Node{
{Id: node.id, Address: node.address},
{Id: node.id, Address: addr, Port: port},
},
}); err != nil {
node.Close()
@@ -134,7 +166,20 @@ func newNode(n *network) (*node, error) {
// wait forever to connect
// TODO: do something with the links we receive
<-linkChan
link := <-linkChan
// process this link
go node.manage(link)
go func() {
// process any further new links
select {
case l := <-linkChan:
go node.manage(l)
case <-node.closed:
return
}
}()
return node, nil
}
@@ -158,28 +203,82 @@ func (n *node) accept(l transport.Listener) error {
}()
// create a new link
// generate a new link
link := &link{
// link has a unique id
id: uuid.New().String(),
// proto marshaler
codec: proto.Marshaler{},
// link has a socket
socket: sock,
// for generating leases,
node: n,
id: uuid.New().String(),
// the send queue,
queue: make(chan *Message, 128),
}
// create a new network socket
sk := new(socket)
sk.node = n
sk.codec = proto.Marshaler{}
sk.socket = sock
// set link socket
link.socket = sk
log.Debugf("Accepting connection from %s", link.socket.Remote())
// accept messages on the socket
// blocks forever or until error
if err := link.up(); err != nil {
// TODO: delete link
// wait for the link to be connected
// the remote end will send "Connect"
// and we will return a "Lease"
if err := link.accept(); err != nil {
return
}
log.Debugf("Accepted link from %s", link.socket.Remote())
// save with the remote address as the key
// where we attempt to connect to nodes
// we do not connect to the same thing
n.Lock()
n.links[link.socket.Remote()] = link
n.Unlock()
// manage the link for its lifetime
n.manage(link)
})
}
// processes the send queue
func (n *node) process() {
for {
select {
case <-n.closed:
return
// process outbound messages on the send queue
// these messages are received from n.Send
case m := <-n.send:
// queue the message on each link
// TODO: more than likely use proxy
n.RLock()
for _, l := range n.links {
l.queue <- m
}
n.RUnlock()
}
}
}
func (n *node) manage(l *link) {
// now process inbound messages on the link
// assumption is this handles everything else
for {
// get a message on the link
m := new(Message)
if err := l.recv(m, nil); err != nil {
// ???
return
}
select {
case <-n.closed:
return
// send to the recv channel e.g node.Accept()
case n.recv <- m:
}
}
}
// connect attempts to periodically connect to new nodes in the network.
// It will only do this if it has less than 3 connections. this method
// is called by network.Connect and fired in a go routine after establishing
@@ -188,30 +287,37 @@ func (n *node) accept(l transport.Listener) error {
func (n *node) connect(linkChan chan *link) {
// TODO: adjustable ticker
t := time.NewTicker(time.Second)
var lease *pb.Lease
for {
select {
// exit when told to do so
case <-n.closed:
return
// on every tick check the number of links and then attempt
// to connect to new nodes if we don't have sufficient links
case <-t.C:
n.mtx.RLock()
n.RLock()
// only start processing if we have less than 3 links
if len(n.links) > 2 {
n.mtx.RUnlock()
n.RUnlock()
continue
}
// get a list of link addresses so we don't reconnect
// to the ones we're already connected to
nodes := map[string]bool{}
for _, l := range n.links {
nodes[l.lease.Node.Address] = true
for addr, _ := range n.links {
// id is the lookup address used to connect
nodes[addr] = true
}
n.mtx.RUnlock()
// unlock our read lock
n.RUnlock()
// lookup records for our network
records := n.network.lookup(n.registry)
// for each record check we haven't already got a connection
@@ -224,53 +330,53 @@ func (n *node) connect(linkChan chan *link) {
for _, record := range records {
// skip existing connections
if nodes[record.Address] {
log.Debugf("Skipping connection to %s", record.Address)
continue
}
// attempt to connect and create a link
log.Debugf("Dialing connection to %s", record.Address)
// connect to the node
s, err := n.transport.Dial(record.Address)
sock, err := n.transport.Dial(record.Address)
if err != nil {
log.Debugf("Dialing connection error %v", err)
continue
}
// create a new socket
sk := &socket{
node: n,
codec: &proto.Marshaler{},
socket: s,
}
// broadcast a "connect" request and get back "lease"
// this is your tunnel to the outside world and to the network
// then push updates and messages over this link
// first connect will not have a lease so we get one with node id/address
l, err := sk.connect(lease)
if err != nil {
s.Close()
continue
}
// set lease for next time
lease = l
// create a new link with the lease and socket
link := &link{
codec: &proto.Marshaler{},
id: uuid.New().String(),
lease: lease,
node: n,
socket: sock,
queue: make(chan *Message, 128),
socket: sk,
}
// bring up the link
go link.up()
log.Debugf("Connecting link to %s", record.Address)
// connect the link:
// this broadcasts a "connect" request and gets back a "lease"
// this is the tunnel to the outside world and to the network
// then push updates and messages over this link
// first connect will not have a lease so we get one with node id/address
if err := link.connect(); err != nil {
// shit
link.Close()
continue
}
log.Debugf("Connected link to %s", record.Address)
n.Lock()
// set lease for next time we connect to anything else
// we want to use the same lease for that. in future
// we may have to expire the lease
lease = link.lease
// save the new link
n.mtx.Lock()
n.links[link.id] = link
n.mtx.Unlock()
n.links[link.socket.Remote()] = link
n.Unlock()
// drop this down the link channel to the network
// so it can manage the links
@@ -280,8 +386,6 @@ func (n *node) connect(linkChan chan *link) {
default:
}
}
case <-n.closed:
return
}
}
}
@@ -296,14 +400,17 @@ func (n *node) Close() error {
case <-n.closed:
return nil
default:
// mark as closed
close(n.closed)
// shutdown all the links
n.mtx.Lock()
n.Lock()
for id, link := range n.links {
link.down()
link.Close()
delete(n.links, id)
}
n.mtx.Unlock()
n.Unlock()
// deregister self
n.registry.Deregister(&registry.Service{
Name: "network:" + n.network.Id(),
@@ -311,14 +418,29 @@ func (n *node) Close() error {
{Id: n.id, Address: n.address},
},
})
// shutdown the listener
return n.listener.Close()
}
return nil
}
// Accept receives the incoming messages from all links
func (n *node) Accept() (*Message, error) {
// process the inbound cruft
for {
select {
case m, ok := <-n.recv:
if !ok {
return nil, errors.New("connection closed")
}
// return the message
return m, nil
case <-n.closed:
return nil, errors.New("connection closed")
}
}
// we never get here
return nil, nil
}
@@ -326,22 +448,13 @@ func (n *node) Network() string {
return n.network.id
}
// Send propagates a message over all links. This should probably use its proxy.
func (n *node) Send(m *Message) error {
n.mtx.RLock()
defer n.mtx.RUnlock()
var gerr error
// send to all links
// TODO: be smarter
for _, link := range n.links {
// TODO: process the error, do some link flap detection
// blackhole the connection, etc
if err := link.socket.send(m, nil); err != nil {
gerr = err
continue
}
select {
case <-n.closed:
return errors.New("connection closed")
case n.send <- m:
// send the message
}
return gerr
return nil
}