105 lines
3.3 KiB
Go
105 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"log"
|
|
"net"
|
|
"time"
|
|
|
|
"github.com/g3n/engine/core"
|
|
"github.com/g3n/engine/geometry"
|
|
"github.com/g3n/engine/graphic"
|
|
"github.com/g3n/engine/material"
|
|
"github.com/g3n/engine/math32"
|
|
)
|
|
|
|
var dials []Dial
|
|
|
|
type Dial struct {
|
|
Connection net.Conn // the real deal underlying TCP connection
|
|
Geo *geometry.Geometry // the 3D geometry
|
|
Mat *material.Standard // the material / color
|
|
Mesh *graphic.Mesh // the combined geometry and material
|
|
Node *core.Node // pointer to node in scene, required for removing the object if connection goes down
|
|
|
|
}
|
|
|
|
// Keeps the pool full, replaces stale connections, and at the same time creates the objects in the 3D scenes representing physical connections
|
|
// should be ran in its own goroutine
|
|
func connPoolWatchdog(serverAddress string, maxPoolSize int, scene *core.Node) {
|
|
|
|
dials = make([]Dial, 0)
|
|
|
|
tcpAddr, err := net.ResolveTCPAddr("tcp4", serverAddress)
|
|
if err != nil {
|
|
log.Fatalf("failed to resolve serverAddress '%s': %v", serverAddress, err)
|
|
}
|
|
|
|
for {
|
|
|
|
removed := 0
|
|
// Check status of existing open connections in pool
|
|
for i, dial := range dials {
|
|
if !isConnUp(dial.Connection) { // TBD: this should be moved to check before first write to the socket file descriptor instead of polling here
|
|
log.Printf("closing bad idle connection and removing from pool - %s", dial.Connection.LocalAddr().String())
|
|
dial.Connection.Close()
|
|
removeCompleted := scene.Remove(dial.Mesh)
|
|
log.Printf("removed: %v", removeCompleted)
|
|
|
|
dials = append(dials[:i-removed], dials[i-removed+1:]...)
|
|
removed++
|
|
}
|
|
}
|
|
|
|
// fill any empty slots in the pool with fresh connections
|
|
for poolSize := len(dials); poolSize < maxPoolSize; poolSize++ {
|
|
log.Printf("Current pool size is '%d', desired pool size is '%d' - opening new connection...", poolSize, maxPoolSize)
|
|
conn, err := net.DialTCP("tcp", nil, tcpAddr)
|
|
if err != nil {
|
|
log.Printf("failed to dial TCP connection: %v", err)
|
|
break
|
|
}
|
|
|
|
conn.SetKeepAlive(true)
|
|
conn.SetKeepAlivePeriod(time.Second * 5)
|
|
|
|
dial := Dial{Connection: conn, Geo: geometry.NewBox(1, 1, 1), Mat: material.NewStandard(math32.NewColor("LimeGreen"))}
|
|
dial.Mesh = graphic.NewMesh(dial.Geo, dial.Mat)
|
|
dial.Node = scene.Add(dial.Mesh)
|
|
dials = append(dials, dial)
|
|
}
|
|
|
|
// Update the position of the connections on the scene
|
|
padding := float32(200 / (len(dials) + 1)) // space between the connection objects in 3D space
|
|
currX := float32(len(dials)/2) * -padding // variable gets updated, this is the initial starting position (left most connection in 3D space)
|
|
if len(dials)%2 == 0 {
|
|
currX += padding / 2
|
|
}
|
|
//currX := padding - 100
|
|
for _, dial := range dials {
|
|
dial.Mesh.SetPositionX(currX)
|
|
currX += padding
|
|
}
|
|
|
|
time.Sleep(time.Second * 5) // random sleep, AKA evidence this shouldn't be a watchdog,
|
|
// this whole function should be event based instead of polling
|
|
}
|
|
}
|
|
|
|
// Checks with OS to ensure that a connection is still active
|
|
// returns err if connection is not active
|
|
func isConnUp(conn net.Conn) bool {
|
|
conn.SetReadDeadline(time.Now().Add(time.Millisecond * 300))
|
|
|
|
buf := make([]byte, 128)
|
|
_, err := conn.Read(buf)
|
|
if err != nil {
|
|
log.Printf("connection error detected: %v", err)
|
|
return false
|
|
}
|
|
|
|
var zero time.Time
|
|
conn.SetReadDeadline(zero)
|
|
|
|
return true
|
|
}
|