Lock sorted fronts

Author: myleshorton

cache.go

@@ -42,7 +42,7 @@ func (f *fronted) prepopulateFronts(cacheFile string) {
 	now := time.Now()
 
 	// update last succeeded status of masquerades based on cached values
-	for _, fr := range f.fronts {
+	for _, fr := range f.fronts.fronts {
 		for _, cf := range cachedFronts {
 			sameFront := cf.ProviderID == fr.getProviderID() && cf.Domain == fr.getDomain() && cf.IpAddress == fr.getIpAddress()
 			cachedValueFresh := now.Sub(fr.lastSucceeded()) < f.maxAllowedCachedAge
@@ -81,10 +81,7 @@ func (f *fronted) maintainCache(cacheFile string) {
 func (f *fronted) updateCache(cacheFile string) {
 	log.Debugf("Updating cache at %v", cacheFile)
 	cache := f.fronts.sortedCopy()
-	sizeToSave := len(cache)
-	if f.maxCacheSize < sizeToSave {
-		sizeToSave = f.maxCacheSize
-	}
+	sizeToSave := min(f.maxCacheSize, len(cache))
 	b, err := json.Marshal(cache[:sizeToSave])
 	if err != nil {
 		log.Errorf("Unable to marshal cache to JSON: %v", err)

cache_test.go

@@ -29,7 +29,7 @@ func TestCaching(t *testing.T) {
 	log.Debug("Creating fronted")
 	makeFronted := func() *fronted {
 		f := &fronted{
-			fronts:              make(sortedFronts, 0, 1000),
+			fronts:              newSortedFronts(0),
 			maxAllowedCachedAge: 250 * time.Millisecond,
 			maxCacheSize:        4,
 			cacheSaveInterval:   50 * time.Millisecond,
@@ -51,7 +51,7 @@ func TestCaching(t *testing.T) {
 	f := makeFronted()
 
 	log.Debug("Adding fronts")
-	f.fronts = append(f.fronts, mb, mc, md)
+	f.fronts.fronts = append(f.fronts.fronts, mb, mc, md)
 
 	readCached := func() []*front {
 		log.Debug("Reading cached fronts")

front.go

@@ -360,20 +360,28 @@ func NewStatusCodeValidator(reject []int) ResponseValidator {
 	}
 }
 
-// slice of masquerade sorted by last vetted time
-type sortedFronts []Front
+// fronts sorted by last vetted time
+type sortedFronts struct {
+	fronts []Front
+	mu     sync.RWMutex
+}
 
-var frontsMu sync.RWMutex
+func newSortedFronts(size int) *sortedFronts {
+	return &sortedFronts{
+		fronts: make([]Front, size),
+		mu:     sync.RWMutex{},
+	}
+}
 
-func (m sortedFronts) Len() int      { return len(m) }
-func (m sortedFronts) Swap(i, j int) { m[i], m[j] = m[j], m[i] }
-func (m sortedFronts) Less(i, j int) bool {
-	if m[i].lastSucceeded().After(m[j].lastSucceeded()) {
+func (m *sortedFronts) Len() int      { return len(m.fronts) }
+func (m *sortedFronts) Swap(i, j int) { m.fronts[i], m.fronts[j] = m.fronts[j], m.fronts[i] }
+func (m *sortedFronts) Less(i, j int) bool {
+	if m.fronts[i].lastSucceeded().After(m.fronts[j].lastSucceeded()) {
 		return true
-	} else if m[j].lastSucceeded().After(m[i].lastSucceeded()) {
+	} else if m.fronts[j].lastSucceeded().After(m.fronts[i].lastSucceeded()) {
 		return false
 	} else {
-		return m[i].getIpAddress() < m[j].getIpAddress()
+		return m.fronts[i].getIpAddress() < m.fronts[j].getIpAddress()
 	}
 }
 
@@ -382,26 +390,27 @@ func (m *sortedFronts) sortedCopy() []Front {
 	defer m.mu.Unlock()
 	c := make([]Front, len(m.fronts))
 	copy(c, m.fronts)
-	sort.Sort(sortedFronts{fronts: c})
+	sf := sortedFronts{fronts: c}
+	sort.Sort(&sf)
 	return c
 }
 
-func (m *sortedFronts) addFronts(fronts []Front) {
+func (m *sortedFronts) addFronts(fronts *sortedFronts) {
 	// Add new masquerades to the existing masquerades slice, but add them at the beginning.
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	m.fronts = append(fronts, m.fronts...)
+	m.fronts = append(fronts.fronts, m.fronts...)
 }
 
 func (m *sortedFronts) size() int {
-	m.mu.Lock()
-	defer m.mu.Unlock()
+	m.mu.RLock()
+	defer m.mu.RUnlock()
 	return len(m.fronts)
 }
 
 func (m *sortedFronts) frontAt(i int) Front {
-	m.mu.Lock()
-	defer m.mu.Unlock()
+	m.mu.RLock()
+	defer m.mu.RUnlock()
 	return m.fronts[i]
 }
 

fronted.go

@@ -49,7 +49,7 @@ var (
 // an implementation of http.RoundTripper for the convenience of callers.
 type fronted struct {
 	certPool            atomic.Value
-	fronts              sortedFronts
+	fronts              *sortedFronts
 	maxAllowedCachedAge time.Duration
 	maxCacheSize        int
 	cacheFile           string
@@ -102,7 +102,7 @@ func NewFronted(options ...Option) Fronted {
 
 	f := &fronted{
 		certPool:            atomic.Value{},
-		fronts:              make(sortedFronts, 0),
+		fronts:              newSortedFronts(1000),
 		maxAllowedCachedAge: defaultMaxAllowedCachedAge,
 		maxCacheSize:        defaultMaxCacheSize,
 		cacheSaveInterval:   defaultCacheSaveInterval,
@@ -559,7 +559,7 @@ func copyProviders(providers map[string]*Provider, countryCode string) map[strin
 	return providersCopy
 }
 
-func loadFronts(providers map[string]*Provider, cacheDirty chan interface{}) sortedFronts {
+func loadFronts(providers map[string]*Provider, cacheDirty chan interface{}) *sortedFronts {
 	log.Debugf("Loading candidates for %d providers", len(providers))
 	defer log.Debug("Finished loading candidates")
 
@@ -569,7 +569,7 @@ func loadFronts(providers map[string]*Provider, cacheDirty chan interface{}) sor
 		size += len(p.Masquerades)
 	}
 
-	fronts := make(sortedFronts, size)
+	fronts := newSortedFronts(size)
 
 	// Note that map iteration order is random, so the order of the providers is automatically randomized.
 	index := 0
@@ -588,7 +588,7 @@ func loadFronts(providers map[string]*Provider, cacheDirty chan interface{}) sor
 		}
 
 		for _, c := range sh {
-			fronts[index] = newFront(c, key, cacheDirty)
+			fronts.fronts[index] = newFront(c, key, cacheDirty)
 			index++
 		}
 	}

fronted_test.go

@@ -155,7 +155,7 @@ func doTestDomainFronting(t *testing.T, cacheFile string, expectedMasqueradesAtE
 	// Check the number of masquerades at the end, waiting until we get the right number
 	masqueradesAtEnd := 0
 	for i := 0; i < 1000; i++ {
-		masqueradesAtEnd = len(d.fronts)
+		masqueradesAtEnd = len(d.fronts.fronts)
 		if masqueradesAtEnd == expectedMasqueradesAtEnd {
 			break
 		}
@@ -761,9 +761,9 @@ func TestFindWorkingMasquerades(t *testing.T) {
 			}
 			f.providers = make(map[string]*Provider)
 			f.providers["testProviderId"] = NewProvider(nil, "", nil, nil, nil, nil, "")
-			f.fronts = make(sortedFronts, len(tt.masquerades))
-			for i, m := range tt.masquerades {
-				f.fronts[i] = m
+			f.fronts = newSortedFronts(0)
+			for _, m := range tt.masquerades {
+				f.fronts.fronts = append(f.fronts.fronts, m)
 			}
 
 			f.tryAllFronts()
@@ -806,9 +806,9 @@ func TestLoadFronts(t *testing.T) {
 	cacheDirty := make(chan interface{}, 10)
 	masquerades := loadFronts(providers, cacheDirty)
 
-	assert.Equal(t, 4, len(masquerades), "Unexpected number of masquerades loaded")
+	assert.Equal(t, 4, len(masquerades.fronts), "Unexpected number of masquerades loaded")
 
-	for _, m := range masquerades {
+	for _, m := range masquerades.fronts {
 		assert.True(t, expected[m.getDomain()], "Unexpected masquerade domain: %s", m.getDomain())
 	}
 }