github.com/grange74/docker@v1.6.0-rc3/daemon/networkdriver/portallocator/portallocator_test.go (about) 1 package portallocator 2 3 import ( 4 "net" 5 "testing" 6 ) 7 8 func TestRequestNewPort(t *testing.T) { 9 p := New() 10 11 port, err := p.RequestPort(defaultIP, "tcp", 0) 12 if err != nil { 13 t.Fatal(err) 14 } 15 16 if expected := p.Begin; port != expected { 17 t.Fatalf("Expected port %d got %d", expected, port) 18 } 19 } 20 21 func TestRequestSpecificPort(t *testing.T) { 22 p := New() 23 24 port, err := p.RequestPort(defaultIP, "tcp", 5000) 25 if err != nil { 26 t.Fatal(err) 27 } 28 if port != 5000 { 29 t.Fatalf("Expected port 5000 got %d", port) 30 } 31 } 32 33 func TestReleasePort(t *testing.T) { 34 p := New() 35 36 port, err := p.RequestPort(defaultIP, "tcp", 5000) 37 if err != nil { 38 t.Fatal(err) 39 } 40 if port != 5000 { 41 t.Fatalf("Expected port 5000 got %d", port) 42 } 43 44 if err := p.ReleasePort(defaultIP, "tcp", 5000); err != nil { 45 t.Fatal(err) 46 } 47 } 48 49 func TestReuseReleasedPort(t *testing.T) { 50 p := New() 51 52 port, err := p.RequestPort(defaultIP, "tcp", 5000) 53 if err != nil { 54 t.Fatal(err) 55 } 56 if port != 5000 { 57 t.Fatalf("Expected port 5000 got %d", port) 58 } 59 60 if err := p.ReleasePort(defaultIP, "tcp", 5000); err != nil { 61 t.Fatal(err) 62 } 63 64 port, err = p.RequestPort(defaultIP, "tcp", 5000) 65 if err != nil { 66 t.Fatal(err) 67 } 68 } 69 70 func TestReleaseUnreadledPort(t *testing.T) { 71 p := New() 72 73 port, err := p.RequestPort(defaultIP, "tcp", 5000) 74 if err != nil { 75 t.Fatal(err) 76 } 77 if port != 5000 { 78 t.Fatalf("Expected port 5000 got %d", port) 79 } 80 81 port, err = p.RequestPort(defaultIP, "tcp", 5000) 82 83 switch err.(type) { 84 case ErrPortAlreadyAllocated: 85 default: 86 t.Fatalf("Expected port allocation error got %s", err) 87 } 88 } 89 90 func TestUnknowProtocol(t *testing.T) { 91 if _, err := New().RequestPort(defaultIP, "tcpp", 0); err != ErrUnknownProtocol { 92 t.Fatalf("Expected error %s got %s", ErrUnknownProtocol, err) 93 } 94 } 95 96 func TestAllocateAllPorts(t *testing.T) { 97 p := New() 98 99 for i := 0; i <= p.End-p.Begin; i++ { 100 port, err := p.RequestPort(defaultIP, "tcp", 0) 101 if err != nil { 102 t.Fatal(err) 103 } 104 105 if expected := p.Begin + i; port != expected { 106 t.Fatalf("Expected port %d got %d", expected, port) 107 } 108 } 109 110 if _, err := p.RequestPort(defaultIP, "tcp", 0); err != ErrAllPortsAllocated { 111 t.Fatalf("Expected error %s got %s", ErrAllPortsAllocated, err) 112 } 113 114 _, err := p.RequestPort(defaultIP, "udp", 0) 115 if err != nil { 116 t.Fatal(err) 117 } 118 119 // release a port in the middle and ensure we get another tcp port 120 port := p.Begin + 5 121 if err := p.ReleasePort(defaultIP, "tcp", port); err != nil { 122 t.Fatal(err) 123 } 124 newPort, err := p.RequestPort(defaultIP, "tcp", 0) 125 if err != nil { 126 t.Fatal(err) 127 } 128 if newPort != port { 129 t.Fatalf("Expected port %d got %d", port, newPort) 130 } 131 132 // now pm.last == newPort, release it so that it's the only free port of 133 // the range, and ensure we get it back 134 if err := p.ReleasePort(defaultIP, "tcp", newPort); err != nil { 135 t.Fatal(err) 136 } 137 port, err = p.RequestPort(defaultIP, "tcp", 0) 138 if err != nil { 139 t.Fatal(err) 140 } 141 if newPort != port { 142 t.Fatalf("Expected port %d got %d", newPort, port) 143 } 144 } 145 146 func BenchmarkAllocatePorts(b *testing.B) { 147 p := New() 148 149 for i := 0; i < b.N; i++ { 150 for i := 0; i <= p.End-p.Begin; i++ { 151 port, err := p.RequestPort(defaultIP, "tcp", 0) 152 if err != nil { 153 b.Fatal(err) 154 } 155 156 if expected := p.Begin + i; port != expected { 157 b.Fatalf("Expected port %d got %d", expected, port) 158 } 159 } 160 p.ReleaseAll() 161 } 162 } 163 164 func TestPortAllocation(t *testing.T) { 165 p := New() 166 167 ip := net.ParseIP("192.168.0.1") 168 ip2 := net.ParseIP("192.168.0.2") 169 if port, err := p.RequestPort(ip, "tcp", 80); err != nil { 170 t.Fatal(err) 171 } else if port != 80 { 172 t.Fatalf("Acquire(80) should return 80, not %d", port) 173 } 174 port, err := p.RequestPort(ip, "tcp", 0) 175 if err != nil { 176 t.Fatal(err) 177 } 178 if port <= 0 { 179 t.Fatalf("Acquire(0) should return a non-zero port") 180 } 181 182 if _, err := p.RequestPort(ip, "tcp", port); err == nil { 183 t.Fatalf("Acquiring a port already in use should return an error") 184 } 185 186 if newPort, err := p.RequestPort(ip, "tcp", 0); err != nil { 187 t.Fatal(err) 188 } else if newPort == port { 189 t.Fatalf("Acquire(0) allocated the same port twice: %d", port) 190 } 191 192 if _, err := p.RequestPort(ip, "tcp", 80); err == nil { 193 t.Fatalf("Acquiring a port already in use should return an error") 194 } 195 if _, err := p.RequestPort(ip2, "tcp", 80); err != nil { 196 t.Fatalf("It should be possible to allocate the same port on a different interface") 197 } 198 if _, err := p.RequestPort(ip2, "tcp", 80); err == nil { 199 t.Fatalf("Acquiring a port already in use should return an error") 200 } 201 if err := p.ReleasePort(ip, "tcp", 80); err != nil { 202 t.Fatal(err) 203 } 204 if _, err := p.RequestPort(ip, "tcp", 80); err != nil { 205 t.Fatal(err) 206 } 207 208 port, err = p.RequestPort(ip, "tcp", 0) 209 if err != nil { 210 t.Fatal(err) 211 } 212 port2, err := p.RequestPort(ip, "tcp", port+1) 213 if err != nil { 214 t.Fatal(err) 215 } 216 port3, err := p.RequestPort(ip, "tcp", 0) 217 if err != nil { 218 t.Fatal(err) 219 } 220 if port3 == port2 { 221 t.Fatal("Requesting a dynamic port should never allocate a used port") 222 } 223 } 224 225 func TestNoDuplicateBPR(t *testing.T) { 226 p := New() 227 228 if port, err := p.RequestPort(defaultIP, "tcp", p.Begin); err != nil { 229 t.Fatal(err) 230 } else if port != p.Begin { 231 t.Fatalf("Expected port %d got %d", p.Begin, port) 232 } 233 234 if port, err := p.RequestPort(defaultIP, "tcp", 0); err != nil { 235 t.Fatal(err) 236 } else if port == p.Begin { 237 t.Fatalf("Acquire(0) allocated the same port twice: %d", port) 238 } 239 }