126 lines
3.5 KiB
Go
126 lines
3.5 KiB
Go
package allregions
|
|
|
|
import (
|
|
"fmt"
|
|
"net"
|
|
|
|
"github.com/cloudflare/cloudflared/logger"
|
|
)
|
|
|
|
// Regions stores Cloudflare edge network IPs, partitioned into two regions.
|
|
// This is NOT thread-safe. Users of this package should use it with a lock.
|
|
type Regions struct {
|
|
region1 Region
|
|
region2 Region
|
|
}
|
|
|
|
// ------------------------------------
|
|
// Constructors
|
|
// ------------------------------------
|
|
|
|
// ResolveEdge resolves the Cloudflare edge, returning all regions discovered.
|
|
func ResolveEdge(logger logger.Service) (*Regions, error) {
|
|
addrLists, err := edgeDiscovery(logger)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(addrLists) < 2 {
|
|
return nil, fmt.Errorf("expected at least 2 Cloudflare Regions regions, but SRV only returned %v", len(addrLists))
|
|
}
|
|
return &Regions{
|
|
region1: NewRegion(addrLists[0]),
|
|
region2: NewRegion(addrLists[1]),
|
|
}, nil
|
|
}
|
|
|
|
// StaticEdge creates a list of edge addresses from the list of hostnames.
|
|
// Mainly used for testing connectivity.
|
|
func StaticEdge(hostnames []string, logger logger.Service) (*Regions, error) {
|
|
resolved := ResolveAddrs(hostnames, logger)
|
|
if len(resolved) == 0 {
|
|
return nil, fmt.Errorf("failed to resolve any edge address")
|
|
}
|
|
return NewNoResolve(resolved), nil
|
|
}
|
|
|
|
// NewNoResolve doesn't resolve the edge. Instead it just uses the given addresses.
|
|
// You probably only need this for testing.
|
|
func NewNoResolve(addrs []*net.TCPAddr) *Regions {
|
|
region1 := make([]*net.TCPAddr, 0)
|
|
region2 := make([]*net.TCPAddr, 0)
|
|
for i, v := range addrs {
|
|
if i%2 == 0 {
|
|
region1 = append(region1, v)
|
|
} else {
|
|
region2 = append(region2, v)
|
|
}
|
|
}
|
|
|
|
return &Regions{
|
|
region1: NewRegion(region1),
|
|
region2: NewRegion(region2),
|
|
}
|
|
}
|
|
|
|
// ------------------------------------
|
|
// Methods
|
|
// ------------------------------------
|
|
|
|
// GetAnyAddress returns an arbitrary address from the larger region.
|
|
func (rs *Regions) GetAnyAddress() *net.TCPAddr {
|
|
if addr := rs.region1.GetAnyAddress(); addr != nil {
|
|
return addr
|
|
}
|
|
return rs.region2.GetAnyAddress()
|
|
}
|
|
|
|
// AddrUsedBy finds the address used by the given connection.
|
|
// Returns nil if the connection isn't using an address.
|
|
func (rs *Regions) AddrUsedBy(connID int) *net.TCPAddr {
|
|
if addr := rs.region1.AddrUsedBy(connID); addr != nil {
|
|
return addr
|
|
}
|
|
return rs.region2.AddrUsedBy(connID)
|
|
}
|
|
|
|
// GetUnusedAddr gets an unused addr from the edge, excluding the given addr. Prefer to use addresses
|
|
// evenly across both regions.
|
|
func (rs *Regions) GetUnusedAddr(excluding *net.TCPAddr, connID int) *net.TCPAddr {
|
|
if rs.region1.AvailableAddrs() > rs.region2.AvailableAddrs() {
|
|
return getAddrs(excluding, connID, &rs.region1, &rs.region2)
|
|
}
|
|
|
|
return getAddrs(excluding, connID, &rs.region2, &rs.region1)
|
|
}
|
|
|
|
// getAddrs tries to grab address form `first` region, then `second` region
|
|
// this is an unrolled loop over 2 element array
|
|
func getAddrs(excluding *net.TCPAddr, connID int, first *Region, second *Region) *net.TCPAddr {
|
|
addr := first.GetUnusedIP(excluding)
|
|
if addr != nil {
|
|
first.Use(addr, connID)
|
|
return addr
|
|
}
|
|
addr = second.GetUnusedIP(excluding)
|
|
if addr != nil {
|
|
second.Use(addr, connID)
|
|
return addr
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// AvailableAddrs returns how many edge addresses aren't used.
|
|
func (rs *Regions) AvailableAddrs() int {
|
|
return rs.region1.AvailableAddrs() + rs.region2.AvailableAddrs()
|
|
}
|
|
|
|
// GiveBack the address so that other connections can use it.
|
|
// Returns true if the address is in this edge.
|
|
func (rs *Regions) GiveBack(addr *net.TCPAddr) bool {
|
|
if found := rs.region1.GiveBack(addr); found {
|
|
return found
|
|
}
|
|
return rs.region2.GiveBack(addr)
|
|
}
|