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) }