remove the tunnel
This commit is contained in:
Asim Aslam
parent
327029beff
commit
c5a282ddd3
@ -1,229 +0,0 @@
|
||||
package tunnel
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"errors"
|
||||
"fmt"
|
||||
"sync"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/micro/go-micro/network/transport"
|
||||
)
|
||||
|
||||
// tun represents a network tunnel
|
||||
type tun struct {
|
||||
// interface to use
|
||||
net Interface
|
||||
|
||||
// connect
|
||||
mtx sync.RWMutex
|
||||
connected bool
|
||||
|
||||
// the send channel
|
||||
send chan *message
|
||||
// close channel
|
||||
closed chan bool
|
||||
|
||||
// sockets
|
||||
sockets map[string]*socket
|
||||
}
|
||||
|
||||
// create new tunnel
|
||||
func newTunnel(net Interface) *tun {
|
||||
return &tun{
|
||||
net: net,
|
||||
send: make(chan *message, 128),
|
||||
closed: make(chan bool),
|
||||
sockets: make(map[string]*socket),
|
||||
}
|
||||
}
|
||||
|
||||
func (t *tun) getSocket(id string) (*socket, bool) {
|
||||
// get the socket
|
||||
t.mtx.RLock()
|
||||
s, ok := t.sockets[id]
|
||||
t.mtx.RUnlock()
|
||||
return s, ok
|
||||
}
|
||||
|
||||
func (t *tun) newSocket(id string) *socket {
|
||||
// new id if it doesn't exist
|
||||
if len(id) == 0 {
|
||||
id = uuid.New().String()
|
||||
}
|
||||
|
||||
// hash the id
|
||||
h := sha256.New()
|
||||
h.Write([]byte(id))
|
||||
id = fmt.Sprintf("%x", h.Sum(nil))
|
||||
|
||||
// new socket
|
||||
s := &socket{
|
||||
id: id,
|
||||
closed: make(chan bool),
|
||||
recv: make(chan *message, 128),
|
||||
send: t.send,
|
||||
}
|
||||
|
||||
// save socket
|
||||
t.mtx.Lock()
|
||||
t.sockets[id] = s
|
||||
t.mtx.Unlock()
|
||||
|
||||
// return socket
|
||||
return s
|
||||
}
|
||||
|
||||
// process outgoing messages
|
||||
func (t *tun) process() {
|
||||
// manage the send buffer
|
||||
// all pseudo sockets throw everything down this
|
||||
for {
|
||||
select {
|
||||
case msg := <-t.send:
|
||||
nmsg := &Message{
|
||||
Header: msg.data.Header,
|
||||
Body: msg.data.Body,
|
||||
}
|
||||
|
||||
// set the stream id on the outgoing message
|
||||
nmsg.Header["Micro-Stream"] = msg.id
|
||||
|
||||
// send the message via the interface
|
||||
if err := t.net.Send(nmsg); err != nil {
|
||||
// no op
|
||||
// TODO: do something
|
||||
}
|
||||
case <-t.closed:
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// process incoming messages
|
||||
func (t *tun) listen() {
|
||||
for {
|
||||
// process anything via the net interface
|
||||
msg, err := t.net.Recv()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
// a stream id
|
||||
id := msg.Header["Micro-Stream"]
|
||||
|
||||
// get the socket
|
||||
s, exists := t.getSocket(id)
|
||||
if !exists {
|
||||
// no op
|
||||
continue
|
||||
}
|
||||
|
||||
// is the socket closed?
|
||||
select {
|
||||
case <-s.closed:
|
||||
// closed
|
||||
delete(t.sockets, id)
|
||||
continue
|
||||
default:
|
||||
// process
|
||||
}
|
||||
|
||||
// is the socket new?
|
||||
select {
|
||||
// if its new it will block here
|
||||
case <-s.wait:
|
||||
// its not new
|
||||
default:
|
||||
// its new
|
||||
// set remote address of the socket
|
||||
s.remote = msg.Header["Remote"]
|
||||
close(s.wait)
|
||||
}
|
||||
|
||||
tmsg := &transport.Message{
|
||||
Header: msg.Header,
|
||||
Body: msg.Body,
|
||||
}
|
||||
|
||||
// TODO: don't block on queuing
|
||||
// append to recv backlog
|
||||
s.recv <- &message{id: id, data: tmsg}
|
||||
}
|
||||
}
|
||||
|
||||
// Close the tunnel
|
||||
func (t *tun) Close() error {
|
||||
t.mtx.Lock()
|
||||
defer t.mtx.Unlock()
|
||||
|
||||
if !t.connected {
|
||||
return nil
|
||||
}
|
||||
|
||||
select {
|
||||
case <-t.closed:
|
||||
return nil
|
||||
default:
|
||||
// close all the sockets
|
||||
for _, s := range t.sockets {
|
||||
s.Close()
|
||||
}
|
||||
// close the connection
|
||||
close(t.closed)
|
||||
t.connected = false
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Connect the tunnel
|
||||
func (t *tun) Connect() error {
|
||||
t.mtx.Lock()
|
||||
defer t.mtx.Unlock()
|
||||
|
||||
// already connected
|
||||
if t.connected {
|
||||
return nil
|
||||
}
|
||||
|
||||
// set as connected
|
||||
t.connected = true
|
||||
// create new close channel
|
||||
t.closed = make(chan bool)
|
||||
|
||||
// process messages to be sent
|
||||
go t.process()
|
||||
// process incoming messages
|
||||
go t.listen()
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Dial an address
|
||||
func (t *tun) Dial(addr string) (Conn, error) {
|
||||
c := t.newSocket(addr)
|
||||
// set remote
|
||||
c.remote = addr
|
||||
// set local
|
||||
c.local = t.net.Addr()
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (t *tun) Accept(addr string) (Conn, error) {
|
||||
c := t.newSocket(addr)
|
||||
// set remote
|
||||
c.remote = t.net.Addr()
|
||||
// set local
|
||||
c.local = addr
|
||||
|
||||
select {
|
||||
case <-c.closed:
|
||||
return nil, errors.New("error creating socket")
|
||||
// wait for the first message
|
||||
case <-c.wait:
|
||||
}
|
||||
|
||||
// return socket
|
||||
return c, nil
|
||||
}
|
||||
@ -1,82 +0,0 @@
|
||||
package tunnel
|
||||
|
||||
import (
|
||||
"errors"
|
||||
|
||||
"github.com/micro/go-micro/network/transport"
|
||||
)
|
||||
|
||||
// socket is our pseudo socket for transport.Socket
|
||||
type socket struct {
|
||||
// socket id based on Micro-Stream
|
||||
id string
|
||||
// closed
|
||||
closed chan bool
|
||||
// remote addr
|
||||
remote string
|
||||
// local addr
|
||||
local string
|
||||
// send chan
|
||||
send chan *message
|
||||
// recv chan
|
||||
recv chan *message
|
||||
// wait until we have a connection
|
||||
wait chan bool
|
||||
}
|
||||
|
||||
// message is sent over the send channel
|
||||
type message struct {
|
||||
// socket id
|
||||
id string
|
||||
// transport data
|
||||
data *transport.Message
|
||||
}
|
||||
|
||||
func (s *socket) Remote() string {
|
||||
return s.remote
|
||||
}
|
||||
|
||||
func (s *socket) Local() string {
|
||||
return s.local
|
||||
}
|
||||
|
||||
func (s *socket) Id() string {
|
||||
return s.id
|
||||
}
|
||||
|
||||
func (s *socket) Send(m *transport.Message) error {
|
||||
select {
|
||||
case <-s.closed:
|
||||
return errors.New("socket is closed")
|
||||
default:
|
||||
// no op
|
||||
}
|
||||
// append to backlog
|
||||
s.send <- &message{id: s.id, data: m}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *socket) Recv(m *transport.Message) error {
|
||||
select {
|
||||
case <-s.closed:
|
||||
return errors.New("socket is closed")
|
||||
default:
|
||||
// no op
|
||||
}
|
||||
// recv from backlog
|
||||
msg := <-s.recv
|
||||
// set message
|
||||
*m = *msg.data
|
||||
// return nil
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *socket) Close() error {
|
||||
select {
|
||||
case <-s.closed:
|
||||
// no op
|
||||
default:
|
||||
close(s.closed)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@ -1,62 +0,0 @@
|
||||
package tunnel
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/micro/go-micro/network/transport"
|
||||
)
|
||||
|
||||
func TestTunnelSocket(t *testing.T) {
|
||||
s := &socket{
|
||||
id: "1",
|
||||
closed: make(chan bool),
|
||||
remote: "remote",
|
||||
local: "local",
|
||||
send: make(chan *message, 1),
|
||||
recv: make(chan *message, 1),
|
||||
wait: make(chan bool),
|
||||
}
|
||||
|
||||
// check addresses local and remote
|
||||
if s.Local() != s.local {
|
||||
t.Fatalf("Expected s.Local %s got %s", s.local, s.Local())
|
||||
}
|
||||
if s.Remote() != s.remote {
|
||||
t.Fatalf("Expected s.Remote %s got %s", s.remote, s.Remote())
|
||||
}
|
||||
|
||||
// send a message
|
||||
s.Send(&transport.Message{Header: map[string]string{}})
|
||||
|
||||
// get sent message
|
||||
msg := <-s.send
|
||||
|
||||
if msg.id != s.id {
|
||||
t.Fatalf("Expected sent message id %s got %s", s.id, msg.id)
|
||||
}
|
||||
|
||||
// recv a message
|
||||
msg.data.Header["Foo"] = "bar"
|
||||
s.recv <- msg
|
||||
|
||||
m := new(transport.Message)
|
||||
s.Recv(m)
|
||||
|
||||
// check header
|
||||
if m.Header["Foo"] != "bar" {
|
||||
t.Fatalf("Did not receive correct message %+v", m)
|
||||
}
|
||||
|
||||
// close the connection
|
||||
s.Close()
|
||||
|
||||
// check connection
|
||||
err := s.Send(m)
|
||||
if err == nil {
|
||||
t.Fatal("Expected closed connection")
|
||||
}
|
||||
err = s.Recv(m)
|
||||
if err == nil {
|
||||
t.Fatal("Expected closed connection")
|
||||
}
|
||||
}
|
||||
@ -1,64 +0,0 @@
|
||||
// Package tunnel provides a network tunnel
|
||||
package tunnel
|
||||
|
||||
import (
|
||||
"github.com/micro/go-micro/config/options"
|
||||
"github.com/micro/go-micro/network/transport"
|
||||
)
|
||||
|
||||
// Tunnel creates a network tunnel
|
||||
type Tunnel interface {
|
||||
// Connect connects the tunnel
|
||||
Connect() error
|
||||
// Close closes the tunnel
|
||||
Close() error
|
||||
// Dial an endpoint
|
||||
Dial(addr string) (Conn, error)
|
||||
// Accept connections
|
||||
Accept(addr string) (Conn, error)
|
||||
}
|
||||
|
||||
// Conn return a transport socket with a unique id.
|
||||
// This means Conn can be used as a transport.Socket
|
||||
type Conn interface {
|
||||
// Unique id of the connection
|
||||
Id() string
|
||||
// Underlying socket
|
||||
transport.Socket
|
||||
}
|
||||
|
||||
// A network interface to use for sending/receiving.
|
||||
// When Tunnel.Connect is called it starts processing
|
||||
// messages over the interface.
|
||||
type Interface interface {
|
||||
// Address of the interface
|
||||
Addr() string
|
||||
// Receive new messages
|
||||
Recv() (*Message, error)
|
||||
// Send messages
|
||||
Send(*Message) error
|
||||
}
|
||||
|
||||
// Messages received over the interface
|
||||
type Message struct {
|
||||
Header map[string]string
|
||||
Body []byte
|
||||
}
|
||||
|
||||
// NewTunnel creates a new tunnel
|
||||
func NewTunnel(opts ...options.Option) Tunnel {
|
||||
options := options.NewOptions(opts...)
|
||||
|
||||
i, ok := options.Values().Get("tunnel.net")
|
||||
if !ok {
|
||||
// wtf
|
||||
return nil
|
||||
}
|
||||
|
||||
return newTunnel(i.(Interface))
|
||||
}
|
||||
|
||||
// WithInterface passes in the interface
|
||||
func WithInterface(net Interface) options.Option {
|
||||
return options.WithValue("tunnel.net", net)
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user