frp/test/e2e/pkg/port/port.go

114 lines
2.0 KiB
Go
Raw Normal View History

2020-06-02 22:48:55 +08:00
package port
import (
"fmt"
"net"
2021-03-31 16:57:39 +08:00
"sync"
2020-06-02 22:48:55 +08:00
"k8s.io/apimachinery/pkg/util/sets"
)
type Allocator struct {
reserved sets.Int
used sets.Int
2021-03-31 16:57:39 +08:00
mu sync.Mutex
2020-06-02 22:48:55 +08:00
}
// NewAllocator return a port allocator for testing.
// Example: from: 10, to: 20, mod 4, index 1
// Reserved ports: 13, 17
func NewAllocator(from int, to int, mod int, index int) *Allocator {
pa := &Allocator{
reserved: sets.NewInt(),
used: sets.NewInt(),
}
for i := from; i <= to; i++ {
if i%mod == index {
pa.reserved.Insert(i)
}
}
return pa
}
func (pa *Allocator) Get() int {
2021-03-31 16:57:39 +08:00
return pa.GetByName("")
}
func (pa *Allocator) GetByName(portName string) int {
var builder *nameBuilder
if portName == "" {
builder = &nameBuilder{}
} else {
var err error
builder, err = unmarshalFromName(portName)
if err != nil {
fmt.Println(err, portName)
return 0
}
}
pa.mu.Lock()
defer pa.mu.Unlock()
2020-06-02 22:48:55 +08:00
for i := 0; i < 10; i++ {
2021-03-31 16:57:39 +08:00
port := pa.getByRange(builder.rangePortFrom, builder.rangePortTo)
2020-06-02 22:48:55 +08:00
if port == 0 {
return 0
}
l, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", port))
if err != nil {
// Maybe not controlled by us, mark it used.
pa.used.Insert(port)
continue
}
l.Close()
2021-03-31 16:57:39 +08:00
udpAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("127.0.0.1:%d", port))
if err != nil {
continue
}
udpConn, err := net.ListenUDP("udp", udpAddr)
if err != nil {
// Maybe not controlled by us, mark it used.
pa.used.Insert(port)
continue
}
udpConn.Close()
2020-06-02 22:48:55 +08:00
pa.used.Insert(port)
return port
}
return 0
}
2021-03-31 16:57:39 +08:00
func (pa *Allocator) getByRange(from, to int) int {
if from <= 0 {
port, _ := pa.reserved.PopAny()
return port
}
// choose a random port between from - to
ports := pa.reserved.UnsortedList()
for _, port := range ports {
if port >= from && port <= to {
return port
}
}
return 0
}
2020-06-02 22:48:55 +08:00
func (pa *Allocator) Release(port int) {
2021-03-31 16:57:39 +08:00
if port <= 0 {
return
}
pa.mu.Lock()
defer pa.mu.Unlock()
2020-06-02 22:48:55 +08:00
if pa.used.Has(port) {
pa.used.Delete(port)
pa.reserved.Insert(port)
}
}