117 lines
3.3 KiB
Go
117 lines
3.3 KiB
Go
package docker
|
|
|
|
import (
|
|
"github.com/dotcloud/docker/pkg/iptables"
|
|
"github.com/dotcloud/docker/proxy"
|
|
"net"
|
|
"testing"
|
|
)
|
|
|
|
func TestPortAllocation(t *testing.T) {
|
|
ip := net.ParseIP("192.168.0.1")
|
|
ip2 := net.ParseIP("192.168.0.2")
|
|
allocator, err := newPortAllocator()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if port, err := allocator.Acquire(ip, 80); err != nil {
|
|
t.Fatal(err)
|
|
} else if port != 80 {
|
|
t.Fatalf("Acquire(80) should return 80, not %d", port)
|
|
}
|
|
port, err := allocator.Acquire(ip, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if port <= 0 {
|
|
t.Fatalf("Acquire(0) should return a non-zero port")
|
|
}
|
|
if _, err := allocator.Acquire(ip, port); err == nil {
|
|
t.Fatalf("Acquiring a port already in use should return an error")
|
|
}
|
|
if newPort, err := allocator.Acquire(ip, 0); err != nil {
|
|
t.Fatal(err)
|
|
} else if newPort == port {
|
|
t.Fatalf("Acquire(0) allocated the same port twice: %d", port)
|
|
}
|
|
if _, err := allocator.Acquire(ip, 80); err == nil {
|
|
t.Fatalf("Acquiring a port already in use should return an error")
|
|
}
|
|
if _, err := allocator.Acquire(ip2, 80); err != nil {
|
|
t.Fatalf("It should be possible to allocate the same port on a different interface")
|
|
}
|
|
if _, err := allocator.Acquire(ip2, 80); err == nil {
|
|
t.Fatalf("Acquiring a port already in use should return an error")
|
|
}
|
|
if err := allocator.Release(ip, 80); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := allocator.Acquire(ip, 80); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
type StubProxy struct {
|
|
frontendAddr *net.Addr
|
|
backendAddr *net.Addr
|
|
}
|
|
|
|
func (proxy *StubProxy) Run() {}
|
|
func (proxy *StubProxy) Close() {}
|
|
func (proxy *StubProxy) FrontendAddr() net.Addr { return *proxy.frontendAddr }
|
|
func (proxy *StubProxy) BackendAddr() net.Addr { return *proxy.backendAddr }
|
|
|
|
func NewStubProxy(frontendAddr, backendAddr net.Addr) (proxy.Proxy, error) {
|
|
return &StubProxy{
|
|
frontendAddr: &frontendAddr,
|
|
backendAddr: &backendAddr,
|
|
}, nil
|
|
}
|
|
|
|
func TestPortMapper(t *testing.T) {
|
|
// FIXME: is this iptables chain still used anywhere?
|
|
var chain *iptables.Chain
|
|
mapper := &PortMapper{
|
|
tcpMapping: make(map[string]*net.TCPAddr),
|
|
tcpProxies: make(map[string]proxy.Proxy),
|
|
udpMapping: make(map[string]*net.UDPAddr),
|
|
udpProxies: make(map[string]proxy.Proxy),
|
|
iptables: chain,
|
|
defaultIp: net.IP("0.0.0.0"),
|
|
proxyFactoryFunc: NewStubProxy,
|
|
}
|
|
|
|
dstIp1 := net.ParseIP("192.168.0.1")
|
|
dstIp2 := net.ParseIP("192.168.0.2")
|
|
srcAddr1 := &net.TCPAddr{Port: 1080, IP: net.ParseIP("172.16.0.1")}
|
|
srcAddr2 := &net.TCPAddr{Port: 1080, IP: net.ParseIP("172.16.0.2")}
|
|
|
|
if err := mapper.Map(dstIp1, 80, srcAddr1); err != nil {
|
|
t.Fatalf("Failed to allocate port: %s", err)
|
|
}
|
|
|
|
if mapper.Map(dstIp1, 80, srcAddr1) == nil {
|
|
t.Fatalf("Port is in use - mapping should have failed")
|
|
}
|
|
|
|
if mapper.Map(dstIp1, 80, srcAddr2) == nil {
|
|
t.Fatalf("Port is in use - mapping should have failed")
|
|
}
|
|
|
|
if err := mapper.Map(dstIp2, 80, srcAddr2); err != nil {
|
|
t.Fatalf("Failed to allocate port: %s", err)
|
|
}
|
|
|
|
if mapper.Unmap(dstIp1, 80, "tcp") != nil {
|
|
t.Fatalf("Failed to release port")
|
|
}
|
|
|
|
if mapper.Unmap(dstIp2, 80, "tcp") != nil {
|
|
t.Fatalf("Failed to release port")
|
|
}
|
|
|
|
if mapper.Unmap(dstIp2, 80, "tcp") == nil {
|
|
t.Fatalf("Port already released, but no error reported")
|
|
}
|
|
}
|