func assertSRVRecordsMatchPort(t *testing.T, records []dns.RR, port ...int) {
expectedPorts := sets.NewInt(port...)
gotPorts := sets.NewInt()
for _, r := range records {
if srv, ok := r.(*dns.SRV); !ok {
t.Errorf("Expected SRV record, got %+v", srv)
} else {
gotPorts.Insert(int(srv.Port))
t.Logf("got %+v", srv)
}
}
if !gotPorts.Equal(expectedPorts) {
t.Errorf("Expected %v got %v", expectedPorts, gotPorts)
}
}
// CheckAvailablePorts ensures that ports used by OpenShift are available on the Docker host
func (c *ClientStartConfig) CheckAvailablePorts(out io.Writer) error {
c.DNSPort = openshift.DefaultDNSPort
err := c.OpenShiftHelper().TestPorts(openshift.AllPorts)
if err == nil {
return nil
}
if !openshift.IsPortsNotAvailableErr(err) {
return err
}
unavailable := sets.NewInt(openshift.UnavailablePorts(err)...)
if unavailable.HasAny(openshift.BasePorts...) {
return errors.NewError("a port needed by OpenShift is not available").WithCause(err)
}
if unavailable.Has(openshift.DefaultDNSPort) {
if unavailable.Has(openshift.AlternateDNSPort) {
return errors.NewError("a port needed by OpenShift is not available").WithCause(err)
}
c.DNSPort = openshift.AlternateDNSPort
fmt.Fprintf(out, "WARNING: Binding DNS on port %d instead of 53, which may not be resolvable from all clients.\n", openshift.AlternateDNSPort)
}
for _, port := range openshift.RouterPorts {
if unavailable.Has(port) {
fmt.Fprintf(out, "WARNING: Port %d is already in use and may cause routing issues for applications.\n", port)
}
}
return nil
}
// AllIssuesForKey returns all known issues matching the key, oldest first.
func (p *IssueCacher) AllIssuesForKey(key string) []int {
p.lock.RLock()
defer p.lock.RUnlock()
got := sets.NewInt()
if n, ok := p.index[issueIndexKey(key)]; ok {
got.Insert([]int(*n)...)
}
if n, ok := p.prevIndex[issueIndexKey(key)]; ok {
got.Insert([]int(*n)...)
}
out := got.List()
sort.Ints(out)
return out
}
// Scans through all subsytems to find pids associated with specified cgroup.
func (m *cgroupManagerImpl) Pids(name CgroupName) []int {
// we need the driver specific name
cgroupFsName := m.Name(name)
// Get a list of processes that we need to kill
pidsToKill := sets.NewInt()
var pids []int
for _, val := range m.subsystems.MountPoints {
dir := path.Join(val, cgroupFsName)
_, err := os.Stat(dir)
if os.IsNotExist(err) {
// The subsystem pod cgroup is already deleted
// do nothing, continue
continue
}
// Get a list of pids that are still charged to the pod's cgroup
pids, err = getCgroupProcs(dir)
if err != nil {
continue
}
pidsToKill.Insert(pids...)
// WalkFunc which is called for each file and directory in the pod cgroup dir
visitor := func(path string, info os.FileInfo, err error) error {
if !info.IsDir() {
return nil
}
pids, err = getCgroupProcs(path)
if err != nil {
glog.V(5).Infof("cgroup manager encountered error getting procs for cgroup path %v", path)
return filepath.SkipDir
}
pidsToKill.Insert(pids...)
return nil
}
// Walk through the pod cgroup directory to check if
// container cgroups haven't been GCed yet. Get attached processes to
// all such unwanted containers under the pod cgroup
if err = filepath.Walk(dir, visitor); err != nil {
glog.V(5).Infof("cgroup manager encountered error scanning pids for directory: %v", dir)
}
}
return pidsToKill.List()
}
func (plugin *NoopNetworkPlugin) Capabilities() utilsets.Int {
return utilsets.NewInt()
}
package restclient
import (
"net/url"
"time"
"github.com/golang/glog"
"k8s.io/kubernetes/pkg/util"
"k8s.io/kubernetes/pkg/util/sets"
)
// Set of resp. Codes that we backoff for.
// In general these should be errors that indicate a server is overloaded.
// These shouldn't be configured by any user, we set them based on conventions
// described in
var serverIsOverloadedSet = sets.NewInt(429)
var maxResponseCode = 499
type BackoffManager interface {
UpdateBackoff(actualUrl *url.URL, err error, responseCode int)
CalculateBackoff(actualUrl *url.URL) time.Duration
Sleep(d time.Duration)
}
// URLBackoff struct implements the semantics on top of Backoff which
// we need for URL specific exponential backoff.
type URLBackoff struct {
// Uses backoff as underlying implementation.
Backoff *util.Backoff
}
func (plugin *ovsPlugin) Capabilities() utilsets.Int {
return utilsets.NewInt(knetwork.NET_PLUGIN_CAPABILITY_SHAPING)
}
func TestInvalidRouteAdmissionFuzzing(t *testing.T) {
p := &fakePlugin{}
admitAll := func(route *routeapi.Route) error { return nil }
recorder := rejectionRecorder{rejections: make(map[string]string)}
admitter := NewHostAdmitter(p, RouteAdmissionFunc(admitAll), true, recorder)
oldest := unversioned.Time{Time: time.Now()}
makeTime := func(d time.Duration) unversioned.Time {
return unversioned.Time{Time: oldest.Add(d)}
}
routes := []struct {
Route *routeapi.Route
ErrIfInt sets.Int
ErrIf sets.String
}{
// Wildcard and explicit allowed in same namespace
{Route: makeRoute("ns1", "r1", "net", "", false, makeTime(0*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns1", "r2", "net", "", true, makeTime(1*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns1", "r3", "www.same.net", "", false, makeTime(2*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns1", "r4", "www.same.net", "", true, makeTime(3*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns1", "r5", "foo.same.net", "", true, makeTime(4*time.Second)), ErrIf: sets.NewString(`ns1/r4`)},
{Route: makeRoute("ns2", "r1", "com", "", false, makeTime(10*time.Second)), ErrIf: sets.NewString(`ns1/r2`)},
{Route: makeRoute("ns2", "r2", "com", "", true, makeTime(11*time.Second)), ErrIf: sets.NewString(`ns1/r1`, `ns1/r2`)},
{Route: makeRoute("ns2", "r3", "www.same.com", "", false, makeTime(12*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns2", "r4", "www.same.com", "", true, makeTime(13*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns2", "r5", "www.same.com", "/abc", true, makeTime(13*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns2", "r6", "foo.same.com", "", true, makeTime(14*time.Second)), ErrIf: sets.NewString(`ns2/r4`)},
{Route: makeRoute("ns2", "r7", "foo.same.com", "/abc", true, makeTime(14*time.Second)), ErrIf: sets.NewString(`ns2/r5`)},
// Fails because of other namespaces
{Route: makeRoute("ns3", "r1", "net", "", false, makeTime(20*time.Second)), ErrIf: sets.NewString(`ns1/r1`, `ns1/r2`, `ns2/r2`)},
{Route: makeRoute("ns3", "r2", "net", "", true, makeTime(21*time.Second)), ErrIf: sets.NewString(`ns1/r1`, `ns1/r2`, `ns2/r1`, `ns2/r2`)},
{Route: makeRoute("ns3", "r3", "net", "/p1", true, makeTime(22*time.Second)), ErrIf: sets.NewString(`ns1/r1`, `ns1/r2`, `ns2/r1`, `ns2/r2`)},
{Route: makeRoute("ns3", "r4", "com", "", false, makeTime(23*time.Second)), ErrIf: sets.NewString(`ns1/r2`, `ns2/r1`, `ns2/r2`)},
{Route: makeRoute("ns3", "r5", "com", "", true, makeTime(24*time.Second)), ErrIf: sets.NewString(`ns1/r1`, `ns1/r2`, `ns2/r1`, `ns2/r2`, `ns3/r2`)},
{Route: makeRoute("ns3", "r6", "com", "/p1/p2", true, makeTime(25*time.Second)), ErrIf: sets.NewString(`ns1/r1`, `ns1/r2`, `ns2/r1`, `ns2/r2`)},
// Interleaved ages between namespaces
{Route: makeRoute("ns4", "r1", "domain1.com", "", false, makeTime(30*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns5", "r1", "domain1.com", "", false, makeTime(31*time.Second)), ErrIf: sets.NewString(`ns4/r1`)},
{Route: makeRoute("ns4", "r2", "domain1.com", "", false, makeTime(32*time.Second)), ErrIf: sets.NewString(`ns4/r1`, `ns5/r1`)},
{Route: makeRoute("ns5", "r2", "domain1.com", "", false, makeTime(33*time.Second)), ErrIf: sets.NewString(`ns4/r1`, `ns5/r1`, `ns4/r2`)},
// namespace with older wildcard wins over specific and wildcard routes in other namespaces
{Route: makeRoute("ns6", "r1", "foo.domain1.com", "", true, makeTime(40*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns7", "r1", "bar.domain1.com", "", true, makeTime(50*time.Second)), ErrIf: sets.NewString(`ns6/r1`)},
{Route: makeRoute("ns7", "r2", "bar.domain1.com", "", false, makeTime(51*time.Second)), ErrIf: sets.NewString(`ns6/r1`)},
{Route: makeRoute("ns7", "r3", "bar.domain1.com", "/foo", false, makeTime(51*time.Second)), ErrIf: sets.NewString(`ns6/r1`)},
{Route: makeRoute("ns8", "r1", "baz.domain1.com", "", true, makeTime(60*time.Second)), ErrIf: sets.NewString(`ns6/r1`, `ns7/r1`, `ns7/r2`, `ns7/r3`)},
{Route: makeRoute("ns8", "r2", "baz.domain1.com", "", false, makeTime(61*time.Second)), ErrIf: sets.NewString(`ns6/r1`, `ns7/r1`)},
// namespace with older explicit host and wildcard wins over specific and wildcard routes in other namespaces
{Route: makeRoute("ns9", "r1", "foo.domain2.com", "", false, makeTime(40*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns10", "r1", "bar.domain2.com", "", true, makeTime(50*time.Second)), ErrIf: sets.NewString(`ns9/r1`)},
{Route: makeRoute("ns10", "r2", "bar.domain2.com", "", false, makeTime(51*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns10", "r3", "foo.domain2.com", "", false, makeTime(52*time.Second)), ErrIf: sets.NewString(`ns9/r1`)},
{Route: makeRoute("ns10", "r4", "foo.domain2.com", "/p1", false, makeTime(53*time.Second)), ErrIf: sets.NewString(`ns9/r1`)},
{Route: makeRoute("ns10", "r5", "foo.domain2.com", "/p2", false, makeTime(54*time.Second)), ErrIf: sets.NewString(`ns9/r1`)},
{Route: makeRoute("ns10", "r6", "foo.domain2.com", "/p1/p2/other", false, makeTime(55*time.Second)), ErrIf: sets.NewString(`ns9/r1`)},
{Route: makeRoute("ns10", "r7", "foo.domain2.com", "/someother", false, makeTime(56*time.Second)), ErrIf: sets.NewString(`ns9/r1`)},
{Route: makeRoute("ns11", "r1", "baz.domain2.com", "", true, makeTime(60*time.Second)), ErrIf: sets.NewString(`ns9/r1`, `ns10/r1`, `ns10/r2`, `ns10/r3`, `ns10/r4`, `ns10/r5`, `ns10/r6`, `ns10/r7`)},
{Route: makeRoute("ns11", "r2", "baz.domain2.com", "", false, makeTime(61*time.Second)), ErrIf: sets.NewString(`ns10/r1`)},
// namespace with specific and wildcard route with paths wins over specific and wildcard routes in other namespaces
{Route: makeRoute("ns12", "r1", "foo.domain3.com", "", false, makeTime(70*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns12", "r2", "bar.domain3.com", "/abc", false, makeTime(71*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns13", "r1", "foo.domain3.com", "", true, makeTime(80*time.Second)), ErrIf: sets.NewString(`ns12/r1`, `ns12/r2`)},
{Route: makeRoute("ns13", "r2", "bar.domain3.com", "", false, makeTime(81*time.Second)), ErrIf: sets.NewString(`ns12/r2`)},
{Route: makeRoute("ns13", "r3", "bar.domain3.com", "/abc", false, makeTime(82*time.Second)), ErrIf: sets.NewString(`ns12/r2`)},
{Route: makeRoute("ns13", "r4", "bar.domain3.com", "/def", false, makeTime(83*time.Second)), ErrIf: sets.NewString(`ns12/r2`)},
{Route: makeRoute("ns13", "r5", "wild.domain3.com", "/aces", true, makeTime(84*time.Second)), ErrIf: sets.NewString(`ns12/r1`, `ns12/r2`)},
{Route: makeRoute("ns13", "r6", "wild.domain3.com", "", true, makeTime(85*time.Second)), ErrIf: sets.NewString(`ns12/r1`, `ns12/r2`, `ns13/r1`)},
{Route: makeRoute("ns14", "r1", "foo.domain3.com", "", false, makeTime(90*time.Second)), ErrIf: sets.NewString(`ns12/r1`, `ns13/r1`, `ns13/r5`, `ns13/r6`)},
{Route: makeRoute("ns14", "r2", "bar.domain3.com", "", false, makeTime(91*time.Second)), ErrIf: sets.NewString(`ns12/r2`, `ns13/r1`, `ns13/r2`, `ns13/r3`, `ns13/r4`, `ns13/r5`, `ns13/r6`)},
// namespace with oldest wildcard and non-wildcard routes with same paths wins
{Route: makeRoute("ns15", "r1", "foo.domain4.com", "", false, makeTime(100*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns15", "r2", "foo.domain4.com", "/abc", false, makeTime(101*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns15", "r3", "foo.domain4.com", "", false, makeTime(102*time.Second)), ErrIf: sets.NewString(`ns15/r1`)},
{Route: makeRoute("ns15", "r4", "foo.domain4.com", "/abc", false, makeTime(103*time.Second)), ErrIf: sets.NewString(`ns15/r2`)},
{Route: makeRoute("ns15", "r5", "www.domain4.com", "", true, makeTime(104*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns15", "r6", "www.domain4.com", "/abc", true, makeTime(105*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns15", "r7", "www.domain4.com", "", true, makeTime(106*time.Second)), ErrIf: sets.NewString(`ns15/r5`)},
{Route: makeRoute("ns15", "r8", "www.domain4.com", "/abc", true, makeTime(107*time.Second)), ErrIf: sets.NewString(`ns15/r6`)},
{Route: makeRoute("ns15", "r9", "www.domain4.com", "/def", true, makeTime(108*time.Second)), ErrIf: sets.NewString()},
{Route: makeRoute("ns15", "r10", "www.domain4.com", "/def", true, makeTime(109*time.Second)), ErrIf: sets.NewString(`ns15/r9`)},
}
nameToIndex := map[string]int{}
for i, tc := range routes {
name := tc.Route.Namespace + "/" + tc.Route.Name
if _, exists := nameToIndex[name]; exists {
t.Fatalf("%d has a duplicate route name %s", i, name)
}
nameToIndex[name] = i
}
for i, tc := range routes {
errIfInt := sets.NewInt()
for name := range tc.ErrIf {
if index, ok := nameToIndex[name]; ok {
errIfInt.Insert(index)
} else {
t.Fatalf("%d references an unknown route name: %s", i, name)
}
}
tc.ErrIfInt = errIfInt
routes[i] = tc
}
rand.Seed(1)
existing := sets.NewInt()
errors := sets.NewString()
for i := 0; i < 10000; i++ {
add := false
switch {
case len(existing) == len(routes):
add = false
case len(existing) == 0:
add = true
default:
add = (rand.Intn(4) > 0)
}
index := 0
eventType := watch.Deleted
if add {
index = rand.Intn(len(routes))
if existing.Has(index) {
eventType = watch.Modified
} else {
eventType = watch.Added
}
} else {
index = existing.List()[rand.Intn(len(existing))]
eventType = watch.Deleted
}
route := routes[index].Route
err := admitter.HandleRoute(eventType, route)
if eventType != watch.Deleted && existing.HasAny(routes[index].ErrIfInt.List()...) {
if err == nil {
errors.Insert(fmt.Sprintf("no error %s route %s/%s (existing=%v, errif=%v)", eventType, route.Namespace, route.Name, existing.List(), routes[index].ErrIfInt.List()))
}
} else {
if err != nil {
errors.Insert(fmt.Sprintf("error %s route %s/%s: %v (existing=%v, errif=%v)", eventType, route.Namespace, route.Name, err.Error(), existing.List(), routes[index].ErrIfInt.List()))
}
}
existingNames := sets.NewString()
for _, routes := range admitter.claimedHosts {
for _, route := range routes {
existingNames.Insert(route.Namespace + "/" + route.Name)
}
}
for _, routes := range admitter.claimedWildcards {
for _, route := range routes {
existingNames.Insert(route.Namespace + "/" + route.Name)
}
}
for _, routes := range admitter.blockedWildcards {
for _, route := range routes {
if !existingNames.Has(route.Namespace + "/" + route.Name) {
t.Fatalf("blockedWildcards has %s/%s, not in claimedHosts or claimedWildcards", route.Namespace, route.Name)
}
}
}
existing = sets.NewInt()
for name := range existingNames {
index, ok := nameToIndex[name]
if !ok {
t.Fatalf("unknown route %s", name)
}
existing.Insert(index)
}
}
if len(errors) > 0 {
t.Errorf("Unexpected errors:\n%s", strings.Join(errors.List(), "\n"))
}
}
func TestValidRouteAdmissionFuzzing(t *testing.T) {
p := &fakePlugin{}
admitAll := func(route *routeapi.Route) error { return nil }
recorder := rejectionRecorder{rejections: make(map[string]string)}
admitter := NewHostAdmitter(p, RouteAdmissionFunc(admitAll), true, recorder)
oldest := unversioned.Time{Time: time.Now()}
makeTime := func(d time.Duration) unversioned.Time {
return unversioned.Time{Time: oldest.Add(d)}
}
routes := []*routeapi.Route{
makeRoute("ns1", "r1", "net", "", false, makeTime(0*time.Second)),
makeRoute("ns2", "r2", "com", "", false, makeTime(1*time.Second)),
makeRoute("ns3", "r3", "domain1.com", "", false, makeTime(2*time.Second)),
makeRoute("ns4", "r4", "domain2.com", "", false, makeTime(3*time.Second)),
makeRoute("ns5", "r5", "foo.domain1.com", "", false, makeTime(4*time.Second)),
makeRoute("ns6", "r6", "bar.domain1.com", "", false, makeTime(5*time.Second)),
makeRoute("ns7", "r7", "sub.foo.domain1.com", "", true, makeTime(6*time.Second)),
makeRoute("ns8", "r8", "sub.bar.domain1.com", "", true, makeTime(7*time.Second)),
makeRoute("ns8", "r9", "sub.bar.domain1.com", "/p1", true, makeTime(8*time.Second)),
makeRoute("ns8", "r10", "sub.bar.domain1.com", "/p2", true, makeTime(9*time.Second)),
makeRoute("ns8", "r11", "sub.bar.domain1.com", "/p1/p2/p3", true, makeTime(10*time.Second)),
makeRoute("ns9", "r12", "sub.bar.domain2.com", "", false, makeTime(11*time.Second)),
makeRoute("ns9", "r13", "sub.bar.domain2.com", "/p1", false, makeTime(12*time.Second)),
makeRoute("ns9", "r14", "sub.bar.domain2.com", "/p2", false, makeTime(13*time.Second)),
}
rand.Seed(1)
existing := sets.NewInt()
errors := sets.NewString()
for i := 0; i < 1000; i++ {
add := false
switch {
case len(existing) == len(routes):
add = false
case len(existing) == 0:
add = true
default:
add = (rand.Intn(4) > 0)
}
index := 0
if add {
index = rand.Intn(len(routes))
if existing.Has(index) {
// t.Logf("%d: updated route %d", i, index)
if err := admitter.HandleRoute(watch.Modified, routes[index]); err != nil {
errors.Insert(fmt.Sprintf("error updating route %s/%s: %v", routes[index].Namespace, routes[index].Name, err.Error()))
}
} else {
// t.Logf("%d: added route %d", i, index)
if err := admitter.HandleRoute(watch.Added, routes[index]); err != nil {
errors.Insert(fmt.Sprintf("error adding route %s/%s: %v", routes[index].Namespace, routes[index].Name, err.Error()))
}
}
existing.Insert(index)
} else {
index = existing.List()[rand.Intn(len(existing))]
// t.Logf("%d: deleted route %d", i, index)
if err := admitter.HandleRoute(watch.Deleted, routes[index]); err != nil {
errors.Insert(fmt.Sprintf("error deleting route %s/%s: %v", routes[index].Namespace, routes[index].Name, err.Error()))
}
existing.Delete(index)
}
}
if len(errors) > 0 {
t.Errorf("Unexpected errors:\n%s", strings.Join(errors.List(), "\n"))
}
if len(recorder.rejections) > 0 {
t.Errorf("Unexpected rejections: %#v", recorder.rejections)
}
}
func (node *OsdnNode) Capabilities() utilsets.Int {
return utilsets.NewInt(knetwork.NET_PLUGIN_CAPABILITY_SHAPING)
}
