Tunnel discover/announce/open/session/close

tunnel/link.go

@@ -9,9 +9,10 @@ import (
 )
 
 type link struct {
+	transport.Socket
+
 	sync.RWMutex
 
-	transport.Socket
 	// unique id of this link e.g uuid
 	// which we define for ourselves
 	id string
@@ -27,11 +28,67 @@ type link struct {
 	// the last time we received a keepalive
 	// on this link from the remote side
 	lastKeepAlive time.Time
+	// channels keeps a mapping of channels and last seen
+	channels map[string]time.Time
+	// stop the link
+	closed chan bool
 }
 
 func newLink(s transport.Socket) *link {
-	return &link{
-		Socket: s,
-		id:     uuid.New().String(),
+	l := &link{
+		Socket:   s,
+		id:       uuid.New().String(),
+		channels: make(map[string]time.Time),
+		closed:   make(chan bool),
+	}
+	go l.run()
+	return l
+}
+
+func (l *link) run() {
+	t := time.NewTicker(time.Minute)
+	defer t.Stop()
+
+	for {
+		select {
+		case <-l.closed:
+			return
+		case <-t.C:
+			// drop any channel mappings older than 2 minutes
+			var kill []string
+			killTime := time.Minute * 2
+
+			l.RLock()
+			for ch, t := range l.channels {
+				if d := time.Since(t); d > killTime {
+					kill = append(kill, ch)
+				}
+			}
+			l.RUnlock()
+
+			// if nothing to kill don't both with a wasted lock
+			if len(kill) == 0 {
+				continue
+			}
+
+			// kill the channels!
+			l.Lock()
+			for _, ch := range kill {
+				delete(l.channels, ch)
+			}
+			l.Unlock()
+		}
+	}
+}
+
+func (l *link) Close() {
+	l.Lock()
+	defer l.Unlock()
+
+	select {
+	case <-l.closed:
+		return
+	default:
+		close(l.closed)
 	}
 }