111 lines
2.8 KiB
Go
111 lines
2.8 KiB
Go
package handler
|
|
|
|
import (
|
|
"context"
|
|
"sort"
|
|
|
|
"github.com/micro/go-micro/errors"
|
|
"github.com/micro/go-micro/network"
|
|
pbNet "github.com/micro/go-micro/network/proto"
|
|
pbRtr "github.com/micro/go-micro/router/proto"
|
|
)
|
|
|
|
// Network implements network handler
|
|
type Network struct {
|
|
Network network.Network
|
|
}
|
|
|
|
// ListRoutes returns a list of routing table routes
|
|
func (n *Network) ListRoutes(ctx context.Context, req *pbRtr.Request, resp *pbRtr.ListResponse) error {
|
|
routes, err := n.Network.Options().Router.Table().List()
|
|
if err != nil {
|
|
return errors.InternalServerError("go.micro.network", "failed to list routes: %s", err)
|
|
}
|
|
|
|
var respRoutes []*pbRtr.Route
|
|
for _, route := range routes {
|
|
respRoute := &pbRtr.Route{
|
|
Service: route.Service,
|
|
Address: route.Address,
|
|
Gateway: route.Gateway,
|
|
Network: route.Network,
|
|
Router: route.Router,
|
|
Link: route.Link,
|
|
Metric: int64(route.Metric),
|
|
}
|
|
respRoutes = append(respRoutes, respRoute)
|
|
}
|
|
|
|
resp.Routes = respRoutes
|
|
|
|
return nil
|
|
}
|
|
|
|
// ListNodes returns a list of all accessible nodes in the network
|
|
func (n *Network) ListNodes(ctx context.Context, req *pbNet.ListRequest, resp *pbNet.ListResponse) error {
|
|
nodes := n.Network.Nodes()
|
|
|
|
var respNodes []*pbNet.Node
|
|
for _, node := range nodes {
|
|
respNode := &pbNet.Node{
|
|
Id: node.Id(),
|
|
Address: node.Address(),
|
|
}
|
|
respNodes = append(respNodes, respNode)
|
|
}
|
|
|
|
resp.Nodes = respNodes
|
|
|
|
return nil
|
|
}
|
|
|
|
// Neighbourhood returns a list of immediate neighbours
|
|
func (n *Network) Neighbourhood(ctx context.Context, req *pbNet.NeighbourhoodRequest, resp *pbNet.NeighbourhoodResponse) error {
|
|
// extract the id of the node to query
|
|
id := req.Id
|
|
// if no id is passed, we assume local node
|
|
if id == "" {
|
|
id = n.Network.Id()
|
|
}
|
|
|
|
// get all the nodes in the network
|
|
nodes := n.Network.Nodes()
|
|
|
|
// sort the slice of nodes
|
|
sort.Slice(nodes, func(i, j int) bool { return nodes[i].Id() <= nodes[j].Id() })
|
|
// find a node with a given id
|
|
i := sort.Search(len(nodes), func(j int) bool { return nodes[j].Id() >= id })
|
|
|
|
var neighbours []*pbNet.Neighbour
|
|
// collect all the nodes in the neighbourhood of the found node
|
|
if i < len(nodes) && nodes[i].Id() == id {
|
|
for _, neighbour := range nodes[i].Neighbourhood() {
|
|
var nodeNeighbours []*pbNet.Node
|
|
for _, nodeNeighbour := range neighbour.Neighbourhood() {
|
|
// don't return yourself in response
|
|
if nodeNeighbour.Id() == n.Network.Id() {
|
|
continue
|
|
}
|
|
nn := &pbNet.Node{
|
|
Id: nodeNeighbour.Id(),
|
|
Address: nodeNeighbour.Address(),
|
|
}
|
|
nodeNeighbours = append(nodeNeighbours, nn)
|
|
}
|
|
// node is present at node[i]
|
|
neighbour := &pbNet.Neighbour{
|
|
Node: &pbNet.Node{
|
|
Id: neighbour.Id(),
|
|
Address: neighbour.Address(),
|
|
},
|
|
Neighbours: nodeNeighbours,
|
|
}
|
|
neighbours = append(neighbours, neighbour)
|
|
}
|
|
}
|
|
|
|
resp.Neighbours = neighbours
|
|
|
|
return nil
|
|
}
|