mirror of
https://github.com/jixishi/SerialTerminalForWindowsTerminal.git
synced 2026-06-16 00:52:44 +00:00
refactor: extract pkg/forward and pkg/luaplugin packages
Move ForwardManager → pkg/forward/Manager and PluginManager → pkg/luaplugin/Manager. Move FoeWardMode (now forward.Mode) with ParseMode/Network/String into pkg/forward. Rename constants: NOT→None, TCPC→TCP, UDPC→UDP. Update all references in main package. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
JiXieShi
@@ -0,0 +1,253 @@
|
||||
package forward
|
||||
|
||||
import (
|
||||
"net"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestManagerTCPFlow(t *testing.T) {
|
||||
listener, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatalf("listen failed: %v", err)
|
||||
}
|
||||
defer listener.Close()
|
||||
|
||||
acceptCh := make(chan net.Conn, 1)
|
||||
errCh := make(chan error, 1)
|
||||
go func() {
|
||||
conn, e := listener.Accept()
|
||||
if e != nil {
|
||||
errCh <- e
|
||||
return
|
||||
}
|
||||
acceptCh <- conn
|
||||
}()
|
||||
|
||||
serialCh := make(chan string, 2)
|
||||
mgr := NewManager(func(b []byte) error {
|
||||
serialCh <- string(b)
|
||||
return nil
|
||||
}, func(string, ...any) {})
|
||||
defer mgr.Close()
|
||||
|
||||
id, err := mgr.Add(TCP, listener.Addr().String())
|
||||
if err != nil {
|
||||
t.Fatalf("Add() failed: %v", err)
|
||||
}
|
||||
|
||||
var serverConn net.Conn
|
||||
select {
|
||||
case serverConn = <-acceptCh:
|
||||
case e := <-errCh:
|
||||
t.Fatalf("accept failed: %v", e)
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatalf("timed out waiting for accepted connection")
|
||||
}
|
||||
defer serverConn.Close()
|
||||
|
||||
items := mgr.List()
|
||||
if len(items) != 1 || items[0].ID != id || !items[0].Enabled {
|
||||
t.Fatalf("unexpected list after add: %+v", items)
|
||||
}
|
||||
|
||||
if err = serverConn.SetReadDeadline(time.Now().Add(2 * time.Second)); err != nil {
|
||||
t.Fatalf("SetReadDeadline failed: %v", err)
|
||||
}
|
||||
mgr.Broadcast([]byte("from-app"))
|
||||
buf := make([]byte, 64)
|
||||
n, err := serverConn.Read(buf)
|
||||
if err != nil {
|
||||
t.Fatalf("server read from broadcast failed: %v", err)
|
||||
}
|
||||
if string(buf[:n]) != "from-app" {
|
||||
t.Fatalf("broadcast payload mismatch got=%q", string(buf[:n]))
|
||||
}
|
||||
|
||||
if _, err = serverConn.Write([]byte("from-remote")); err != nil {
|
||||
t.Fatalf("server write failed: %v", err)
|
||||
}
|
||||
select {
|
||||
case got := <-serialCh:
|
||||
if got != "from-remote" {
|
||||
t.Fatalf("writeToSerial payload mismatch got=%q", got)
|
||||
}
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatalf("timed out waiting for writeToSerial callback")
|
||||
}
|
||||
|
||||
if err = mgr.Disable(id); err != nil {
|
||||
t.Fatalf("Disable() failed: %v", err)
|
||||
}
|
||||
items = mgr.List()
|
||||
if len(items) != 1 || items[0].Enabled {
|
||||
t.Fatalf("Disable() did not update state: %+v", items)
|
||||
}
|
||||
|
||||
if err = mgr.Remove(id); err != nil {
|
||||
t.Fatalf("Remove() failed: %v", err)
|
||||
}
|
||||
if got := mgr.List(); len(got) != 0 {
|
||||
t.Fatalf("expected empty list after remove, got=%+v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerErrorCases(t *testing.T) {
|
||||
mgr := NewManager(func([]byte) error { return nil }, func(string, ...any) {})
|
||||
defer mgr.Close()
|
||||
|
||||
if _, err := mgr.Add(None, "127.0.0.1:1"); err == nil {
|
||||
t.Fatalf("Add(None) expected error")
|
||||
}
|
||||
|
||||
if err := mgr.Remove(999); err == nil {
|
||||
t.Fatalf("Remove(non-existing) expected error")
|
||||
}
|
||||
|
||||
if err := mgr.Disable(999); err == nil {
|
||||
t.Fatalf("Disable(non-existing) expected error")
|
||||
}
|
||||
|
||||
if err := mgr.Enable(999); err == nil {
|
||||
t.Fatalf("Enable(non-existing) expected error")
|
||||
}
|
||||
|
||||
if err := mgr.Update(999, TCP, "127.0.0.1:1"); err == nil {
|
||||
t.Fatalf("Update(non-existing) expected error")
|
||||
}
|
||||
|
||||
listener, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatalf("listen failed: %v", err)
|
||||
}
|
||||
defer listener.Close()
|
||||
|
||||
id, err := mgr.Add(TCP, listener.Addr().String())
|
||||
if err != nil {
|
||||
t.Fatalf("Add() failed: %v", err)
|
||||
}
|
||||
if err = mgr.Update(id, None, "127.0.0.1:1"); err == nil {
|
||||
t.Fatalf("Update(None) expected error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerSetInboundReporter(t *testing.T) {
|
||||
reported := make(chan []byte, 1)
|
||||
mgr := NewManager(func([]byte) error { return nil }, func(string, ...any) {})
|
||||
defer mgr.Close()
|
||||
mgr.SetInboundReporter(func(id int, chunk []byte) {
|
||||
reported <- chunk
|
||||
})
|
||||
// Verify the callback was stored (indirect test)
|
||||
_ = reported
|
||||
}
|
||||
|
||||
func TestManagerBroadcastToDisabled(t *testing.T) {
|
||||
listener, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatalf("listen failed: %v", err)
|
||||
}
|
||||
defer listener.Close()
|
||||
|
||||
writeCh := make(chan []byte, 4)
|
||||
mgr := NewManager(func([]byte) error {
|
||||
writeCh <- nil
|
||||
return nil
|
||||
}, func(string, ...any) {})
|
||||
defer mgr.Close()
|
||||
|
||||
id, err := mgr.Add(TCP, listener.Addr().String())
|
||||
if err != nil {
|
||||
t.Fatalf("Add() failed: %v", err)
|
||||
}
|
||||
|
||||
if err = mgr.Disable(id); err != nil {
|
||||
t.Fatalf("Disable() failed: %v", err)
|
||||
}
|
||||
|
||||
mgr.Broadcast([]byte("should-not-arrive"))
|
||||
|
||||
select {
|
||||
case <-writeCh:
|
||||
t.Fatalf("broadcast should not write to serial when disabled")
|
||||
default:
|
||||
}
|
||||
|
||||
mgr.Broadcast(nil)
|
||||
mgr.Broadcast([]byte{})
|
||||
}
|
||||
|
||||
func TestManagerEnable(t *testing.T) {
|
||||
listener, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatalf("listen failed: %v", err)
|
||||
}
|
||||
defer listener.Close()
|
||||
|
||||
writeCh := make(chan []byte, 2)
|
||||
mgr := NewManager(func([]byte) error {
|
||||
writeCh <- nil
|
||||
return nil
|
||||
}, func(string, ...any) {})
|
||||
defer mgr.Close()
|
||||
|
||||
id, err := mgr.Add(TCP, listener.Addr().String())
|
||||
if err != nil {
|
||||
t.Fatalf("Add() failed: %v", err)
|
||||
}
|
||||
|
||||
if err = mgr.Disable(id); err != nil {
|
||||
t.Fatalf("Disable() failed: %v", err)
|
||||
}
|
||||
|
||||
if err = mgr.Enable(id); err != nil {
|
||||
t.Fatalf("Enable() failed: %v", err)
|
||||
}
|
||||
|
||||
items := mgr.List()
|
||||
if len(items) != 1 || !items[0].Enabled {
|
||||
t.Fatalf("expected enabled after Enable(), got=%+v", items)
|
||||
}
|
||||
|
||||
if err = mgr.Enable(id); err != nil {
|
||||
t.Fatalf("second Enable() should succeed: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestManagerUpdate(t *testing.T) {
|
||||
l1, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatalf("listen 1 failed: %v", err)
|
||||
}
|
||||
defer l1.Close()
|
||||
|
||||
l2, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatalf("listen 2 failed: %v", err)
|
||||
}
|
||||
defer l2.Close()
|
||||
|
||||
mgr := NewManager(func([]byte) error { return nil }, func(string, ...any) {})
|
||||
defer mgr.Close()
|
||||
|
||||
id, err := mgr.Add(TCP, l1.Addr().String())
|
||||
if err != nil {
|
||||
t.Fatalf("Add() failed: %v", err)
|
||||
}
|
||||
|
||||
if err = mgr.Update(id, TCP, l2.Addr().String()); err != nil {
|
||||
t.Fatalf("Update() failed: %v", err)
|
||||
}
|
||||
|
||||
items := mgr.List()
|
||||
if len(items) != 1 || items[0].Address != l2.Addr().String() {
|
||||
t.Fatalf("update should change address, got=%+v", items)
|
||||
}
|
||||
|
||||
if err = mgr.Disable(id); err != nil {
|
||||
t.Fatalf("Disable() failed: %v", err)
|
||||
}
|
||||
if err = mgr.Update(id, TCP, l1.Addr().String()); err != nil {
|
||||
t.Fatalf("Update() on disabled should succeed: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,369 @@
|
||||
// Package forward manages TCP/UDP forwarding targets for serial data.
|
||||
package forward
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net"
|
||||
"sort"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Mode is the forwarding protocol mode.
|
||||
type Mode int
|
||||
|
||||
const (
|
||||
None Mode = iota
|
||||
TCP
|
||||
UDP
|
||||
)
|
||||
|
||||
// ParseMode parses a mode string. Accepts "tcp"/"tcp-c"/"tcpc"/"1" → TCP, "udp"/"udp-c"/"udpc"/"2" → UDP.
|
||||
func ParseMode(v string) (Mode, bool) {
|
||||
switch strings.ToLower(strings.TrimSpace(v)) {
|
||||
case "tcp", "tcp-c", "tcpc", "1":
|
||||
return TCP, true
|
||||
case "udp", "udp-c", "udpc", "2":
|
||||
return UDP, true
|
||||
default:
|
||||
return None, false
|
||||
}
|
||||
}
|
||||
|
||||
func (m Mode) Network() string {
|
||||
switch m {
|
||||
case TCP:
|
||||
return "tcp"
|
||||
case UDP:
|
||||
return "udp"
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
func (m Mode) String() string {
|
||||
switch m {
|
||||
case TCP:
|
||||
return "tcp"
|
||||
case UDP:
|
||||
return "udp"
|
||||
default:
|
||||
return "none"
|
||||
}
|
||||
}
|
||||
|
||||
// Stats holds I/O statistics for a forward target.
|
||||
type Stats struct {
|
||||
ReadBytes uint64
|
||||
WrittenBytes uint64
|
||||
LastError string
|
||||
}
|
||||
|
||||
// Target represents a single forwarding connection.
|
||||
type Target struct {
|
||||
ID int
|
||||
Mode Mode
|
||||
Address string
|
||||
Enabled bool
|
||||
Connected bool
|
||||
CreatedAt time.Time
|
||||
|
||||
conn net.Conn
|
||||
stats Stats
|
||||
mu sync.Mutex
|
||||
closeCh chan struct{}
|
||||
closed bool
|
||||
}
|
||||
|
||||
// Snapshot is a read-only view of a forward target for display.
|
||||
type Snapshot struct {
|
||||
ID int
|
||||
Mode string
|
||||
Address string
|
||||
Enabled bool
|
||||
Connected bool
|
||||
ReadBytes uint64
|
||||
WriteByte uint64
|
||||
LastError string
|
||||
}
|
||||
|
||||
// Manager coordinates forwarding targets.
|
||||
type Manager struct {
|
||||
mu sync.RWMutex
|
||||
targets map[int]*Target
|
||||
nextID int
|
||||
writeToSerial func([]byte) error
|
||||
notify func(string, ...any)
|
||||
onInbound func(int, []byte)
|
||||
}
|
||||
|
||||
// NewManager creates a forwarding manager.
|
||||
func NewManager(writeToSerial func([]byte) error, notify func(string, ...any)) *Manager {
|
||||
return &Manager{
|
||||
targets: make(map[int]*Target),
|
||||
nextID: 1,
|
||||
writeToSerial: writeToSerial,
|
||||
notify: notify,
|
||||
}
|
||||
}
|
||||
|
||||
// SetInboundReporter sets a callback invoked when inbound data arrives from a target.
|
||||
func (m *Manager) SetInboundReporter(fn func(int, []byte)) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
m.onInbound = fn
|
||||
}
|
||||
|
||||
// Add creates and connects a new forward target.
|
||||
func (m *Manager) Add(mode Mode, address string) (int, error) {
|
||||
if mode == None {
|
||||
return 0, fmt.Errorf("forward mode cannot be none")
|
||||
}
|
||||
|
||||
t := &Target{
|
||||
Mode: mode,
|
||||
Address: address,
|
||||
Enabled: true,
|
||||
CreatedAt: time.Now(),
|
||||
closeCh: make(chan struct{}),
|
||||
}
|
||||
|
||||
conn, err := net.Dial(mode.Network(), address)
|
||||
if err != nil {
|
||||
t.stats.LastError = err.Error()
|
||||
return 0, err
|
||||
}
|
||||
|
||||
t.conn = conn
|
||||
t.Connected = true
|
||||
|
||||
m.mu.Lock()
|
||||
t.ID = m.nextID
|
||||
m.nextID++
|
||||
m.targets[t.ID] = t
|
||||
m.mu.Unlock()
|
||||
|
||||
go m.readLoop(t, conn, t.closeCh)
|
||||
m.notify("[forward] #%d %s %s connected", t.ID, t.Mode.String(), t.Address)
|
||||
return t.ID, nil
|
||||
}
|
||||
|
||||
func (m *Manager) readLoop(t *Target, conn net.Conn, stop <-chan struct{}) {
|
||||
buf := make([]byte, 4096)
|
||||
for {
|
||||
n, err := conn.Read(buf)
|
||||
if n > 0 {
|
||||
atomic.AddUint64(&t.stats.ReadBytes, uint64(n))
|
||||
chunk := make([]byte, n)
|
||||
copy(chunk, buf[:n])
|
||||
if wErr := m.writeToSerial(chunk); wErr != nil {
|
||||
t.stats.LastError = wErr.Error()
|
||||
m.notify("[forward] #%d write serial error: %v", t.ID, wErr)
|
||||
} else if m.onInbound != nil {
|
||||
m.onInbound(t.ID, chunk)
|
||||
}
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
t.mu.Lock()
|
||||
if t.conn == conn {
|
||||
t.Connected = false
|
||||
}
|
||||
t.stats.LastError = err.Error()
|
||||
t.mu.Unlock()
|
||||
m.notify("[forward] #%d disconnected: %v", t.ID, err)
|
||||
return
|
||||
}
|
||||
|
||||
select {
|
||||
case <-stop:
|
||||
return
|
||||
default:
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Remove disconnects and removes a target.
|
||||
func (m *Manager) Remove(id int) error {
|
||||
m.mu.Lock()
|
||||
t, ok := m.targets[id]
|
||||
if !ok {
|
||||
m.mu.Unlock()
|
||||
return fmt.Errorf("forward #%d not found", id)
|
||||
}
|
||||
delete(m.targets, id)
|
||||
m.mu.Unlock()
|
||||
|
||||
t.close()
|
||||
m.notify("[forward] #%d removed", id)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Enable (re)connects a target.
|
||||
func (m *Manager) Enable(id int) error {
|
||||
m.mu.RLock()
|
||||
t, ok := m.targets[id]
|
||||
m.mu.RUnlock()
|
||||
if !ok {
|
||||
return fmt.Errorf("forward #%d not found", id)
|
||||
}
|
||||
|
||||
t.mu.Lock()
|
||||
defer t.mu.Unlock()
|
||||
if t.Enabled && t.Connected {
|
||||
return nil
|
||||
}
|
||||
|
||||
conn, err := net.Dial(t.Mode.Network(), t.Address)
|
||||
if err != nil {
|
||||
t.stats.LastError = err.Error()
|
||||
return err
|
||||
}
|
||||
|
||||
t.Enabled = true
|
||||
t.Connected = true
|
||||
t.conn = conn
|
||||
t.closeCh = make(chan struct{})
|
||||
t.closed = false
|
||||
go m.readLoop(t, conn, t.closeCh)
|
||||
m.notify("[forward] #%d enabled", id)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Update changes a target's mode and address, reconnecting if enabled.
|
||||
func (m *Manager) Update(id int, mode Mode, address string) error {
|
||||
if mode == None {
|
||||
return fmt.Errorf("forward mode cannot be none")
|
||||
}
|
||||
|
||||
m.mu.RLock()
|
||||
t, ok := m.targets[id]
|
||||
m.mu.RUnlock()
|
||||
if !ok {
|
||||
return fmt.Errorf("forward #%d not found", id)
|
||||
}
|
||||
|
||||
t.mu.Lock()
|
||||
wasEnabled := t.Enabled
|
||||
t.Mode = mode
|
||||
t.Address = address
|
||||
t.mu.Unlock()
|
||||
|
||||
t.close()
|
||||
|
||||
if !wasEnabled {
|
||||
m.notify("[forward] #%d updated (disabled)", id)
|
||||
return nil
|
||||
}
|
||||
|
||||
return m.Enable(id)
|
||||
}
|
||||
|
||||
// Disable disconnects a target without removing it.
|
||||
func (m *Manager) Disable(id int) error {
|
||||
m.mu.RLock()
|
||||
t, ok := m.targets[id]
|
||||
m.mu.RUnlock()
|
||||
if !ok {
|
||||
return fmt.Errorf("forward #%d not found", id)
|
||||
}
|
||||
|
||||
t.mu.Lock()
|
||||
t.Enabled = false
|
||||
t.mu.Unlock()
|
||||
t.close()
|
||||
m.notify("[forward] #%d disabled", id)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Broadcast sends data to all enabled, connected targets.
|
||||
func (m *Manager) Broadcast(data []byte) {
|
||||
if len(data) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
m.mu.RLock()
|
||||
items := make([]*Target, 0, len(m.targets))
|
||||
for _, t := range m.targets {
|
||||
items = append(items, t)
|
||||
}
|
||||
m.mu.RUnlock()
|
||||
|
||||
for _, t := range items {
|
||||
if !t.Enabled || !t.Connected || t.conn == nil {
|
||||
continue
|
||||
}
|
||||
|
||||
n, err := t.conn.Write(data)
|
||||
if err != nil {
|
||||
t.stats.LastError = err.Error()
|
||||
m.notify("[forward] #%d write error: %v", t.ID, err)
|
||||
continue
|
||||
}
|
||||
|
||||
atomic.AddUint64(&t.stats.WrittenBytes, uint64(n))
|
||||
}
|
||||
}
|
||||
|
||||
// List returns a snapshot of all targets.
|
||||
func (m *Manager) List() []Snapshot {
|
||||
m.mu.RLock()
|
||||
items := make([]Snapshot, 0, len(m.targets))
|
||||
for _, t := range m.targets {
|
||||
items = append(items, Snapshot{
|
||||
ID: t.ID,
|
||||
Mode: t.Mode.String(),
|
||||
Address: t.Address,
|
||||
Enabled: t.Enabled,
|
||||
Connected: t.Connected,
|
||||
ReadBytes: atomic.LoadUint64(&t.stats.ReadBytes),
|
||||
WriteByte: atomic.LoadUint64(&t.stats.WrittenBytes),
|
||||
LastError: t.stats.LastError,
|
||||
})
|
||||
}
|
||||
m.mu.RUnlock()
|
||||
|
||||
sort.Slice(items, func(i, j int) bool {
|
||||
return items[i].ID < items[j].ID
|
||||
})
|
||||
|
||||
return items
|
||||
}
|
||||
|
||||
// Close disconnects and removes all targets.
|
||||
func (m *Manager) Close() {
|
||||
m.mu.Lock()
|
||||
items := make([]*Target, 0, len(m.targets))
|
||||
for _, t := range m.targets {
|
||||
items = append(items, t)
|
||||
}
|
||||
m.targets = map[int]*Target{}
|
||||
m.mu.Unlock()
|
||||
|
||||
for _, t := range items {
|
||||
t.close()
|
||||
}
|
||||
}
|
||||
|
||||
func (t *Target) close() {
|
||||
t.mu.Lock()
|
||||
if t.closed {
|
||||
t.mu.Unlock()
|
||||
return
|
||||
}
|
||||
t.closed = true
|
||||
ch := t.closeCh
|
||||
conn := t.conn
|
||||
t.conn = nil
|
||||
t.Connected = false
|
||||
t.mu.Unlock()
|
||||
|
||||
if ch != nil {
|
||||
close(ch)
|
||||
}
|
||||
if conn != nil {
|
||||
_ = conn.Close()
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user