DNSCache: TTL cleanup implementation. #6740

eloycoto · 2019-01-24T09:41:30Z

The reason for this commit is to avoid large list of identities on fqdn policy
and implement the cleanup process to clean expires IPS and avoid large times on
policyCalculation.

The reason to use a cleanup map in dnsCache is to avoid to loop all the DNS
cache entries, so each second we have a map and a controller will clean the
entries that has some ips expired at that point of time.

The reason to use the controller, is to avoid to have a goroutine with a
timer.Tick each second, and have all in the same goroutine. To avoid leaks,
instead the passing time.Now() use the cache.lastCleanup to get all the entries
from the last run, policy regeneration can take more than 40 seconds in some
huge policies and with this method leak seconds entries int he cleanup map will
not happen.

Tried also with a callback function, but that can block the cache in case of the
long policyCalculation times and DNS proxy will not resolve/response correctly.
Also tried with the channel, but need to have a buffer and the Cilium way is
more related to use a controller.

This PR will not work if #6692 is not merged.

Signed-off-by: Eloy Coto eloy.coto@gmail.com

This change is

aanm · 2019-01-24T10:17:58Z

daemon/fqdn.go

@@ -100,6 +101,17 @@ func (d *Daemon) bootstrapFQDN(restoredEndpoints *endpointRestoreState) (err err
 		fqdn.StartDNSPoller(d.dnsPoller)
 	}

+	// Controller to cleanup TTL expired entries from the DNS policies.
+	controller.NewManager().UpdateController("dns-ttl-cleanup-job", controller.ControllerParams{
+		RunInterval: time.Second,


I'm probably the wrong person to review this PR but do we need to run this controller every second? Can't this be event based on the TTL of the entry?

no, each second the cleanup need to happens to clean the table.

But the entries don't have a TTL for every second

Multiple dns queries has multiple DNS TTL, so each second we need to clean the TTL that has expired after X seconds.

The challenge is knowing when to wake up to expire a specific IP and regenerate policy. We know the expiration time of each entry and setting a timer for the next one to expire is straight-forward Figuring out the expire time for the one after the next is annoying. We would need something like a priority queue (with O(logn) best case update). In theory, most updates will add a new time to the end of this queue (i.e. a new latest time). Still, we can have situations where new entries will expire somewhere in the middle.
Binning the entries into seconds seems like the lowest overhead, since we have as many map entries as we have IPs (or less). The lookup is also constant time for a specific second.

I doubt that we need 1 second accuracy for the TTL. Isn't it enough to expire every 15 seconds?

raybejjani

One thing to change, otherwise LGTM!

raybejjani · 2019-01-24T10:37:04Z

pkg/fqdn/cache.go

+// CleanupExpiredEntries cleans all the expired entries from the lastTime that
+// runs to the give time. It will lock the struct until retrieves all the data.
+// It returns the list of names that need to be deleted from the policies.
+func (c *DNSCache) CleanupExpiredEntries(expires time.Time) []string {


Let's return lastCleanup as well, this way it will be clear what the time range was for logging etc.

pkg/fqdn/cache.go

raybejjani · 2019-01-24T10:42:30Z

pkg/fqdn/cache.go

+		expiredEntries = append(expiredEntries, entries...)
+		delete(c.cleanup, key)
+	}
+	return expiredEntries


Since we now do the actual removal of cacheEntry objects here, we need to do a :

for _, name := range expiredEntries { if entries, exists := c.forward[name]; exists { entries.removeExpired(expiredTime) } }

We also might want to sort and unique the names. If we do both, the loop above already does the uniqueing because of the exists check (if we add to a list only when exists == true).

pkg/fqdn/cache_test.go

raybejjani · 2019-01-24T10:47:11Z

pkg/fqdn/cache.go

+	lastCleanup time.Time
+
+	// cleanup is the map of TTL expiration time and the entries that are going
+	// to expire at that second.


mention that the expiration time is in seconds, and that it is expected that we will delete entries in CleanupExpiredEntries

raybejjani · 2019-01-24T11:01:14Z

pkg/fqdn/cache.go

-	// When lookupTime is much earlier than time.Now(), we may not expire all
-	// entries that should be expired, leaving more work for .Lookup.
-	c.removeExpired(entries, time.Now())
+	c.addNameToCleanup(entry)


This line needs to be in updateWithEntryIPs. This is because we're tracking by IP, but store the whole DNS lookup. The entry may not actually go into the cache if, for a particular IP, there is another lookup that expires later.
In the cases were, for an IP, we are replacing an existing entry, we might need to also replace the cleanup entry. This is because that IP won't actually expire at the original time anymore. It is a little harmless, though.

raybejjani · 2019-01-24T11:02:50Z

daemon/fqdn.go

@@ -100,6 +101,17 @@ func (d *Daemon) bootstrapFQDN(restoredEndpoints *endpointRestoreState) (err err
 		fqdn.StartDNSPoller(d.dnsPoller)
 	}

+	// Controller to cleanup TTL expired entries from the DNS policies.
+	controller.NewManager().UpdateController("dns-ttl-cleanup-job", controller.ControllerParams{


You were right: putting this here makes things a little complicated. We now need a controller for the Endpoint.DNSHistory caches(unless some of the changes below around replacing cleanup entries go in, then it might end up with a steady memory usage).

pkg/fqdn/cache_test.go

raybejjani · 2019-01-24T13:00:39Z

daemon/fqdn.go

@@ -100,6 +101,17 @@ func (d *Daemon) bootstrapFQDN(restoredEndpoints *endpointRestoreState) (err err
 		fqdn.StartDNSPoller(d.dnsPoller)
 	}

+	// Controller to cleanup TTL expired entries from the DNS policies.
+	controller.NewManager().UpdateController("dns-ttl-cleanup-job", controller.ControllerParams{
+		RunInterval: time.Second,


The challenge is knowing when to wake up to expire a specific IP and regenerate policy. We know the expiration time of each entry and setting a timer for the next one to expire is straight-forward Figuring out the expire time for the one after the next is annoying. We would need something like a priority queue (with O(logn) best case update). In theory, most updates will add a new time to the end of this queue (i.e. a new latest time). Still, we can have situations where new entries will expire somewhere in the middle.
Binning the entries into seconds seems like the lowest overhead, since we have as many map entries as we have IPs (or less). The lookup is also constant time for a specific second.

raybejjani · 2019-01-24T13:13:17Z

pkg/fqdn/cache.go

+			c.removeExpired(entries, c.lastCleanup)
+		}
+	}
+	return uniqExpires, c.lastCleanup


Oh, I meant the original lastCleanup at the start of this function, not the final one (which is going to be roughly expires).

raybejjani · 2019-01-24T13:15:38Z

pkg/fqdn/cache.go

+func (c *DNSCache) addNameToCleanup(entry *cacheEntry) {
+	expiration := int64(entry.TTL) + time.Now().Unix()
+	expiredEntries, exists := c.cleanup[expiration]
+	if !exists {


I just realised that the append means we can avoid this if, if you prefer

pkg/fqdn/cache.go

raybejjani · 2019-01-24T13:18:59Z

pkg/fqdn/cache.go

+// delete the entry from the policy when it expires.
+// Need to be called with the lock
+func (c *DNSCache) addNameToCleanup(entry *cacheEntry) {
+	expiration := int64(entry.TTL) + time.Now().Unix()


I just realised that this isn't right. We already set the ExpirationTime in the entry and use that everywhere else. We should probably use it here too, so it is consistent. It will also apply the TTL correctly relative to the lookup time of the data, instead of time.Now() (which will be within the same second most of the time so it would mostly work this way).

raybejjani · 2019-01-24T13:21:44Z

pkg/fqdn/cache.go

@@ -268,6 +323,7 @@ func (c *DNSCache) updateWithEntryIPs(entries ipEntries, entry *cacheEntry) {
 			c.upsertReverse(ipStr, entry)
 		}
 	}
+	c.addNameToCleanup(entry)


This needs to be called when we call c.upsertReverse (just above) otherwise we introduce expirations that aren't actually happening in the cache.

tgraf · 2019-01-25T05:43:49Z

daemon/fqdn.go

@@ -100,6 +101,17 @@ func (d *Daemon) bootstrapFQDN(restoredEndpoints *endpointRestoreState) (err err
 		fqdn.StartDNSPoller(d.dnsPoller)
 	}

+	// Controller to cleanup TTL expired entries from the DNS policies.
+	controller.NewManager().UpdateController("dns-ttl-cleanup-job", controller.ControllerParams{
+		RunInterval: time.Second,


I doubt that we need 1 second accuracy for the TTL. Isn't it enough to expire every 15 seconds?

tgraf · 2019-01-25T05:44:10Z

daemon/fqdn.go

+			d.dnsRuleGen.ForceGenerateDNS(namesToClean)
+			return nil
+		},
+		StopFunc: func() error { return nil },


This can be omitted

houndci-bot · 2019-01-30T17:17:57Z

pkg/fqdn/helpers.go

@@ -165,3 +165,17 @@ func sortedIPsAreEqual(a, b []net.IP) bool {
 func prepareMatchName(matchName string) string {
 	return strings.ToLower(dns.Fqdn(matchName))
 }
+
+func KeepUniqueNames(names []string) []string {


exported function KeepUniqueNames should have comment or be unexported

I have a slight preference for only using the slice instead of making a map. In any case, however we do it we should document the function and explain that the output slice is the same or different.

houndci-bot · 2019-01-30T17:17:57Z

pkg/fqdn/cache.go


+// NewDNSCache returns an initialized DNSCache and set the max host limit to


comment on exported function NewDNSCacheWithLimit should be of the form "NewDNSCacheWithLimit ..."

houndci-bot · 2019-01-30T17:17:57Z

pkg/fqdn/cache.go

@@ -26,6 +26,9 @@ import (
 	"github.com/cilium/cilium/pkg/lock"
 )

+// defines the maximum number of IPs to maintain for each FQDN name


comment on exported var FQDNMaxIPperHost should be of the form "FQDNMaxIPperHost ..."

raybejjani · 2019-01-30T17:24:34Z

daemon/fqdn.go

+			for i, ep := range endpoints {
+				cfg.Cache.UpdateFromCache(ep.DNSHistory, namesToClean, i == 0)
+			}
+			log.Infof("FQDN garbage collector work deleted %d name entries", len(namesToClean))


this is probably a debug... I'm not sure how relevant it is without the list of names deleted

Just a info message to be able to track this down in the future if any issue.

shrug. People keep complaining to me about log lines.
Anyway, can you make it a scopedLog with controller name or whatever we usually put into the controllers? that will make it easier to filter for it.

raybejjani · 2019-01-30T17:26:27Z

daemon/fqdn.go

+			}
+			// A second loop is needed to update the global cache from the
+			// endpoints cache
+			for i, ep := range endpoints {


Also mention: The first update from an endpoint will clear the data in cfg.Cache for each of namesToClean. Looping this way is generally safe despite not locking; If a new lookup happens during these updates the new DNS data will be reinserted from the endpoint.DNSHistory cache that made the request.

raybejjani · 2019-01-30T17:26:56Z

pkg/fqdn/cache.go

+	cleanup map[int64][]string
+
+	// overLimit is a map with the host names that has reached the ips limits
+	// defined by the DNSCache


defined by limit, no?

raybejjani · 2019-01-30T17:27:32Z

pkg/fqdn/cache.go

@@ -154,16 +181,124 @@ func (c *DNSCache) updateWithEntry(entry *cacheEntry) {
 		c.forward[entry.Name] = entries
 	}
 	c.updateWithEntryIPs(entries, entry)
+	if len(entries) > FQDNMaxIPperHost {


this now needs to use c.limit

raybejjani · 2019-01-30T17:27:46Z

pkg/fqdn/cache.go

+	overLimit map[string]bool
+
+	// limit is the number of maximum number of IP per host.
+	limit int


perHostLimit will be more clear when using it later.

raybejjani · 2019-01-30T17:28:45Z

pkg/fqdn/cache.go

+
+// cleanupOverLimitEntries returns the names that has reached the max number of
+// IP per host.
+// Internally the function sort the entries by the TTL.


We should say sorted by expiration time. TTL might be ambiguous and mean the actual TTL seconds value.

raybejjani · 2019-01-30T17:32:16Z

pkg/fqdn/cache.go

-func (c *DNSCache) UpdateFromCache(update *DNSCache) {
+// individually. If any item in the names slice will only update that names.
+// If the clean argument is set to true, all entries will be clean.
+func (c *DNSCache) UpdateFromCache(update *DNSCache, names []string, clean bool) {


names might be better as namesToUpdate or something,

the comment is a little unclear, maybe:
When names is non-nil only those names are updated from update, otherwise all DNS names in update are used.
When clean is true the data in c for each specific name is cleared before the update.

raybejjani · 2019-01-30T17:34:11Z

pkg/option/config.go

@@ -260,6 +260,10 @@ const (
 	// ToFQDNsEmitPollerEvents controls if poller lookups are sent as monitor events
 	ToFQDNsEnablePollerEvents = "tofqdns-enable-poller-events"

+	// ToFQDNsMaxIPsPerHost defines the maximum number of IPs to maintain
+	// for each FQDN name in an endpoint's FQDN cache
+	ToFQDNsMaxIPsPerHost = "tofqdns-max-ip-per-hostname"


tofqdns-endpoint-max-ip-per-hostname might be a little more clear but it is longer.

coveralls · 2019-01-31T14:12:32Z

Coverage increased (+0.02%) to 42.98% when pulling 0e90cfd on eloycoto:FQDNCacheCleanb into 0b3ed95 on cilium:master.

eloycoto · 2019-01-31T14:13:08Z

test-me-please

raybejjani · 2019-01-31T14:11:41Z

daemon/fqdn.go

+			for i, ep := range endpoints {
+				cfg.Cache.UpdateFromCache(ep.DNSHistory, namesToClean, i == 0)
+			}
+			log.Infof("FQDN garbage collector work deleted %d name entries", len(namesToClean))


shrug. People keep complaining to me about log lines.
Anyway, can you make it a scopedLog with controller name or whatever we usually put into the controllers? that will make it easier to filter for it.

raybejjani · 2019-01-31T14:14:43Z

pkg/fqdn/cache.go

 // UpdateFromCache is a utility function that allows updating a DNSCache
 // instance with all the internal entries of another. Latest-Expiration still
 // applies, thus the merged outcome is consistent with adding the entries
 // individually.
-func (c *DNSCache) UpdateFromCache(update *DNSCache) {
+// When namesToUpdate is non-nil only those names are updated from update, otherwise


I guess this isn't wholly true. "When namesToUpdate has non-zero length" might be more correct (since someone might pass in an empty list thinking it will be a no-op).

raybejjani · 2019-01-31T14:16:11Z

pkg/fqdn/cache.go

@@ -173,8 +306,19 @@ func (c *DNSCache) UpdateFromCache(update *DNSCache) {

 	c.Lock()
 	defer c.Unlock()
-
-	for _, newEntries := range update.forward {
+	if len(namesToUpdate) == 0 {


I wonder if it's better to convert the string slice to a map when len(namesToUpdate) != 0 instead. This way, the default case just uses update.forward without doing extra work. It probably won't matter too much in the end.

raybejjani · 2019-01-31T14:29:39Z

pkg/fqdn/cache.go

+			continue
+		}
+		if clean {
+			c.removeExpired(newEntries, time.Now(), time.Now())


I realised that this is wrong. c.removeExpired should only work on entries in c, and not from update. The effect here would be that removeReverse inside removeExpired etc. wouldn't work correctly.
There's also another problem with the assumption I made yesterday. If the first endpoint.DNSHistory doesn't have name then we won't ever clean it. Another problem is that the time.Now() here leaves a bit of a race.
So, I think we are better off not having clean in this function, but call ForceExpire before we call this function in the controller. This should keep things relatively consistent (at the cost of a regex compile).

raybejjani · 2019-01-31T14:32:23Z

pkg/fqdn/cache.go

+		}
+		if clean {
+			c.removeExpired(newEntries, time.Now(), time.Now())
+		}
 		for _, newEntry := range newEntries {
 			c.updateWithEntry(newEntry)


Not related with this PR, but could you add a comment like:
using newEntry from update violates encapsulation but these objects are immutable and so it should be harmless to do this (but still a bad idea).

Alternatively, we can copy newEntry (The type is shallow-copyable in general, unless we also play with IP slices, and if we do we deserve bugs).

raybejjani · 2019-01-31T14:48:36Z

pkg/fqdn/cache.go

+	}
+	toClean := []string{}
+
+	// For global cache the limit maybe is not used at all.


Without knowing about the various instances of this type that we use, this is a little confusing. If you wanted to make sure it was clear, maybe add this comment where we instantiate fqdn.DefaultDNSCache?

raybejjani · 2019-01-31T15:00:54Z

pkg/fqdn/cache.go

 		}
 	}
+
 }

 // removeExpired removes expired (or nil) cacheEntry pointers from entries, an


Since we know the entry we are expiring, we can also remove it from cleanup. This way if someone forgets to run GC we won't leak memory.

raybejjani · 2019-01-31T15:06:19Z

pkg/fqdn/cache.go

+
+	// cleanup is the map of TTL expiration time and the entries that are going
+	// to expire will be deleted by CleanupExpiredEntries.
+	cleanup map[int64][]string


We should explain how cleanup and overlimit are being used more completely here. The difference between them is a little unclear. It's possible something like expirationTimes is a better name but it is longer.
For cleanup:
cleanup maps the TTL expiration times (in seconds since the epoch) to DNS names that expire in that second. On every new insertion where the new data is actually inserted into the cache (i.e. it expires later than an existing entry) cleanup will be updated. CleanupExpiredEntries cleans up these entries on demand.
Note: Lookup functions will not return expired entries, and this is used to proactively enforce expirations.
Note: It is important to periodically call CleanupExpiredEntries otherwise this map will grow forever.
(this last note isn't needed if we remove entries from cleanup during removeExpired)

For overlimit:
overlimit is a set of DNS names that were over the per-host configured limit when they received an update. The excess IPs will be removed when cleanupOverLimitEntries is called, but will continue to be returned by Lookup until then.
Note: It is important to periodically call GC otherwise this map will grow forever (it is very bounded, however).
(this last note isn't needed if we remove entries from overLimit when we insert IPs).

raybejjani · 2019-01-31T15:10:13Z

pkg/fqdn/cache.go

 	// When lookupTime is much earlier than time.Now(), we may not expire all
 	// entries that should be expired, leaving more work for .Lookup.
 	c.removeExpired(entries, time.Now(), time.Time{})
 }

+// AddNameToCleanup adds the IP with the given TTL to the the cleanup map to
+// delete the entry from the policy when it expires.
+// Need to be called with the lock


with a write lock (I think we make the distinction elsewhere)

raybejjani · 2019-01-31T15:12:38Z

pkg/fqdn/cache.go

+		reverse:     make(map[string]nameEntries),
+		lastCleanup: time.Now(),
+		cleanup:     map[int64][]string{},
+		overLimit:   map[string]bool{},


since we set every other field, perhaps we should also set perHostLimit. It is redundant but makes it clear that it was intended. shrug.

raybejjani · 2019-02-04T09:08:13Z

test-me-please (rebased with master)

raybejjani · 2019-02-04T09:08:28Z

sorry @eloycoto I accidentally pressed close!

eloycoto · 2019-02-04T11:49:40Z

test-me-please

tgraf · 2019-02-04T15:42:32Z

Needs a quick refresh:

00:14:45.987     runtime: 104a105
00:14:45.987     runtime: >       --tofqdns-endpoint-max-ip-per-hostname int    Maximum number of IPs to maintain per FQDN name for each endpoint (default 50)
00:14:45.987     runtime: Detected a difference in the cmdref directory
00:14:45.987     runtime: diff -r: diff -r ./Documentation/cmdref/cilium-agent.md /tmp/tmp.20iWrMlkhK/cilium-agent.md
00:14:45.987     runtime: 104a105
00:14:45.987     runtime: >       --tofqdns-endpoint-max-ip-per-hostname int    Maximum number of IPs to maintain per FQDN name for each endpoint (default 50)
00:14:45.987     runtime: Only in ./Documentation/cmdref: cli_index.rst
00:14:45.987     runtime: Only in ./Documentation/cmdref: index.rst
00:14:45.987     runtime: Only in ./Documentation/cmdref: kvstore.rst
00:14:45.987     runtime: Please rerun 'make -C Documentation cmdref' and commit your changes

eloycoto · 2019-02-04T15:59:57Z

test-me-please

ianvernon

LGTM for CLI

The reason for this commit is to avoid large list of identities on fqdn policy and implement the cleanup process to clean expires IPS and avoid large times on policyCalculation. The reason to use a cleanup map in dnsCache is to avoid to loop all the DNS cache entries, so each second we have a map and a controller will clean the entries that has some ips expired at that point of time. The reason to use the controller, is to avoid to have a goroutine with a timer.Tick each second, and have all in the same goroutine. To avoid leaks, instead the passing time.Now() use the cache.lastCleanup to get all the entries from the last run, policy regeneration can take more than 40 seconds in some huge policies and with this method leak seconds entries int he cleanup map will not happen. Tried also with a callback function, but that can block the cache in case of the long policyCalculation times and DNS proxy will not resolve/response correctly. Also tried with the channel, but need to have a buffer and the Cilium way is more related to use a controller. Signed-off-by: Eloy Coto <eloy.coto@gmail.com>

Signed-off-by: Eloy Coto <eloy.coto@gmail.com>

On `updateIPsForName` if the new data has already expired or the old data also expired can be issue in regeneration. Fix cilium#6796 Signed-off-by: Eloy Coto <eloy.coto@gmail.com>

eloycoto · 2019-02-05T08:28:57Z

test-me-please

eloycoto · 2019-02-05T08:29:05Z

Fixed conflict

eloycoto added pending-review area/daemon Impacts operation of the Cilium daemon. labels Jan 24, 2019

eloycoto requested a review from a team January 24, 2019 09:41

aanm reviewed Jan 24, 2019

View reviewed changes

raybejjani suggested changes Jan 24, 2019

View reviewed changes

aanm reviewed Jan 24, 2019

View reviewed changes

pkg/fqdn/cache_test.go Outdated Show resolved Hide resolved

eloycoto force-pushed the FQDNCacheCleanb branch from 8ad7ec0 to 5dcc6c1 Compare January 24, 2019 12:04

eloycoto requested a review from raybejjani January 24, 2019 12:05

raybejjani suggested changes Jan 24, 2019

View reviewed changes

eloycoto force-pushed the FQDNCacheCleanb branch from 5dcc6c1 to 6a8c7eb Compare January 24, 2019 13:50

eloycoto requested a review from raybejjani January 24, 2019 13:51

tgraf requested changes Jan 25, 2019

View reviewed changes

eloycoto added wip and removed pending-review labels Jan 25, 2019

eloycoto force-pushed the FQDNCacheCleanb branch from 6a8c7eb to f8ab6e6 Compare January 30, 2019 17:17

eloycoto requested review from a team as code owners January 30, 2019 17:17

houndci-bot reviewed Jan 30, 2019

View reviewed changes

raybejjani reviewed Jan 30, 2019

View reviewed changes

eloycoto force-pushed the FQDNCacheCleanb branch 5 times, most recently from 73f5cc3 to d9184e2 Compare January 31, 2019 13:53

raybejjani suggested changes Jan 31, 2019

View reviewed changes

eloycoto force-pushed the FQDNCacheCleanb branch from d9184e2 to 1e64506 Compare January 31, 2019 15:52

eloycoto requested a review from a team as a code owner January 31, 2019 15:52

eloycoto force-pushed the FQDNCacheCleanb branch from d3cd5cd to 76a7b58 Compare January 31, 2019 16:35

raybejjani closed this Feb 4, 2019

raybejjani reopened this Feb 4, 2019

raybejjani added this to the 1.4-feature milestone Feb 4, 2019

eloycoto force-pushed the FQDNCacheCleanb branch from b400cce to 80e6795 Compare February 4, 2019 11:49

tgraf approved these changes Feb 4, 2019

View reviewed changes

eloycoto force-pushed the FQDNCacheCleanb branch from 80e6795 to 3e2ddf8 Compare February 4, 2019 15:59

eloycoto added the priority/release-blocker label Feb 4, 2019

ianvernon requested a review from aanm February 4, 2019 19:38

ianvernon approved these changes Feb 4, 2019

View reviewed changes

eloycoto added 3 commits February 5, 2019 09:26

FQDN: Added garbage collector functions.

7ee960c

Signed-off-by: Eloy Coto <eloy.coto@gmail.com>

FQDN Rulegen: Fix issue if ips already expired

0e90cfd

On `updateIPsForName` if the new data has already expired or the old data also expired can be issue in regeneration. Fix cilium#6796 Signed-off-by: Eloy Coto <eloy.coto@gmail.com>

eloycoto force-pushed the FQDNCacheCleanb branch from 3e2ddf8 to 0e90cfd Compare February 5, 2019 08:28

ianvernon merged commit bcb5aa3 into cilium:master Feb 5, 2019

ianvernon mentioned this pull request Feb 5, 2019

v1.4: backports 19-02-05 #6938

Merged

ianvernon added backport-pending/1.4 and removed needs-backport/1.4 labels Feb 5, 2019

raybejjani mentioned this pull request Feb 6, 2019

Track DNS Poller data like endpoint DNS data #6951

Closed

tgraf mentioned this pull request Feb 6, 2019

Some FQDN tests are failing since 6740 was merged #6957

Closed

ianvernon mentioned this pull request Feb 6, 2019

CI: k8s-1.8.K8sFQDNTest Restart Cilium validate that FQDN is still working #6629

Closed

pchaigno mentioned this pull request May 24, 2022

docs: Fix incorrect FQDN flag #19930

Merged


		// NewDNSCache returns an initialized DNSCache and set the max host limit to

DNSCache: TTL cleanup implementation. #6740

DNSCache: TTL cleanup implementation. #6740

Uh oh!

Conversation

eloycoto commented Jan 24, 2019 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

raybejjani left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

coveralls commented Jan 31, 2019 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

eloycoto commented Jan 24, 2019 •

edited

Loading

coveralls commented Jan 31, 2019 •

edited

Loading

raybejjani Jan 31, 2019 •

edited

Loading

raybejjani Jan 31, 2019 •

edited

Loading