Merge branch 'domain-map' into 'master'

Rename 'domains' type to 'domainMap'

See merge request gitlab-org/gitlab-pages!73

3 files changed, 42 insertions, 42 deletions

diff --git a/app.go b/app.go
index 3a032a59..ef436401 100644
--- a/app.go
+++ b/app.go
@@ -29,20 +29,20 @@ var (
 
 type theApp struct {
 	appConfig
-	domains  domains
+	dm       domainMap
 	lock     sync.RWMutex
 	Artifact *artifact.Artifact
 }
 
 func (a *theApp) isReady() bool {
-	return a.domains != nil
+	return a.dm != nil
 }
 
 func (a *theApp) domain(host string) *domain {
 	host = strings.ToLower(host)
 	a.lock.RLock()
 	defer a.lock.RUnlock()
-	domain, _ := a.domains[host]
+	domain, _ := a.dm[host]
 	return domain
 }
 
@@ -157,10 +157,10 @@ func (a *theApp) ServeProxy(ww http.ResponseWriter, r *http.Request) {
 	a.serveContent(ww, r, https)
 }
 
-func (a *theApp) UpdateDomains(domains domains) {
+func (a *theApp) UpdateDomains(dm domainMap) {
 	a.lock.Lock()
 	defer a.lock.Unlock()
-	a.domains = domains
+	a.dm = dm
 }
 
 func (a *theApp) Run() {
diff --git a/domains.go b/domains.go
index c3fff1cf..291b0faa 100644
--- a/domains.go
+++ b/domains.go
@@ -15,11 +15,11 @@ import (
 	"gitlab.com/gitlab-org/gitlab-pages/metrics"
 )
 
-type domains map[string]*domain
+type domainMap map[string]*domain
 
-type domainsUpdater func(domains domains)
+type domainsUpdater func(domainMap)
 
-func (d domains) addDomain(rootDomain, group, projectName string, config *domainConfig) {
+func (dm domainMap) addDomain(rootDomain, group, projectName string, config *domainConfig) {
 	newDomain := &domain{
 		Group:       group,
 		ProjectName: projectName,
@@ -28,12 +28,12 @@ func (d domains) addDomain(rootDomain, group, projectName string, config *domain
 
 	var domainName string
 	domainName = strings.ToLower(config.Domain)
-	d[domainName] = newDomain
+	dm[domainName] = newDomain
 }
 
-func (d domains) updateGroupDomain(rootDomain, group, projectName string, httpsOnly bool) {
+func (dm domainMap) updateGroupDomain(rootDomain, group, projectName string, httpsOnly bool) {
 	domainName := strings.ToLower(group + "." + rootDomain)
-	groupDomain := d[domainName]
+	groupDomain := dm[domainName]
 
 	if groupDomain == nil {
 		groupDomain = &domain{
@@ -46,24 +46,24 @@ func (d domains) updateGroupDomain(rootDomain, group, projectName string, httpsO
 		HTTPSOnly: httpsOnly,
 	}
 
-	d[domainName] = groupDomain
+	dm[domainName] = groupDomain
 }
 
-func (d domains) readProjectConfig(rootDomain string, group, projectName string, config *domainsConfig) {
+func (dm domainMap) readProjectConfig(rootDomain string, group, projectName string, config *domainsConfig) {
 	if config == nil {
 		// This is necessary to preserve the previous behaviour where a
 		// group domain is created even if no config.json files are
 		// loaded successfully. Is it safe to remove this?
-		d.updateGroupDomain(rootDomain, group, projectName, false)
+		dm.updateGroupDomain(rootDomain, group, projectName, false)
 		return
 	}
 
-	d.updateGroupDomain(rootDomain, group, projectName, config.HTTPSOnly)
+	dm.updateGroupDomain(rootDomain, group, projectName, config.HTTPSOnly)
 
 	for _, domainConfig := range config.Domains {
 		config := domainConfig // domainConfig is reused for each loop iteration
 		if domainConfig.Valid(rootDomain) {
-			d.addDomain(rootDomain, group, projectName, &config)
+			dm.addDomain(rootDomain, group, projectName, &config)
 		}
 	}
 }
@@ -117,7 +117,7 @@ type jobResult struct {
 	config  *domainsConfig
 }
 
-func (d domains) ReadGroups(rootDomain string) error {
+func (dm domainMap) ReadGroups(rootDomain string) error {
 	fis, err := godirwalk.ReadDirents(".", nil)
 	if err != nil {
 		return err
@@ -155,7 +155,7 @@ func (d domains) ReadGroups(rootDomain string) error {
 	done := make(chan struct{})
 	go func() {
 		for result := range fanIn {
-			d.readProjectConfig(rootDomain, result.group, result.project, result.config)
+			dm.readProjectConfig(rootDomain, result.group, result.project, result.config)
 		}
 
 		close(done)
@@ -200,8 +200,8 @@ func watchDomains(rootDomain string, updater domainsUpdater, interval time.Durat
 		lastUpdate = update
 
 		started := time.Now()
-		domains := make(domains)
-		if err := domains.ReadGroups(rootDomain); err != nil {
+		dm := make(domainMap)
+		if err := dm.ReadGroups(rootDomain); err != nil {
 			log.WithError(err).Warn("domain scan failed")
 		}
 		duration := time.Since(started).Seconds()
@@ -213,33 +213,33 @@ func watchDomains(rootDomain string, updater domainsUpdater, interval time.Durat
 			hash = strings.TrimSpace(string(update))
 		}
 
-		logConfiguredDomains(domains)
+		logConfiguredDomains(dm)
 
 		log.WithFields(log.Fields{
-			"count(domains)": len(domains),
+			"count(domains)": len(dm),
 			"duration":       duration,
 			"hash":           hash,
 		}).Info("Updated all domains")
 
 		if updater != nil {
-			updater(domains)
+			updater(dm)
 		}
 
 		// Update prometheus metrics
 		metrics.DomainLastUpdateTime.Set(float64(time.Now().UTC().Unix()))
-		metrics.DomainsServed.Set(float64(len(domains)))
+		metrics.DomainsServed.Set(float64(len(dm)))
 		metrics.DomainUpdates.Inc()
 
 		time.Sleep(interval)
 	}
 }
 
-func logConfiguredDomains(ds domains) {
+func logConfiguredDomains(dm domainMap) {
 	if log.GetLevel() == log.DebugLevel {
 		return
 	}
 
-	for h, d := range ds {
+	for h, d := range dm {
 		log.WithFields(log.Fields{
 			"domain": d,
 			"host":   h,
diff --git a/domains_test.go b/domains_test.go
index ab59ac0d..e1196765 100644
--- a/domains_test.go
+++ b/domains_test.go
@@ -15,13 +15,13 @@ import (
 func TestReadProjects(t *testing.T) {
 	setUpTests()
 
-	d := make(domains)
-	err := d.ReadGroups("test.io")
+	dm := make(domainMap)
+	err := dm.ReadGroups("test.io")
 	require.NoError(t, err)
 
 	var domains []string
-	for domain := range d {
-		domains = append(domains, domain)
+	for d := range dm {
+		domains = append(domains, d)
 	}
 
 	expectedDomains := []string{
@@ -47,10 +47,10 @@ func TestReadProjects(t *testing.T) {
 
 	// Check that multiple domains in the same project are recorded faithfully
 	exp1 := &domainConfig{Domain: "test.domain.com"}
-	assert.Equal(t, exp1, d["test.domain.com"].Config)
+	assert.Equal(t, exp1, dm["test.domain.com"].Config)
 
 	exp2 := &domainConfig{Domain: "other.domain.com", Certificate: "test", Key: "key"}
-	assert.Equal(t, exp2, d["other.domain.com"].Config)
+	assert.Equal(t, exp2, dm["other.domain.com"].Config)
 }
 
 // This write must be atomic, otherwise we cannot predict the state of the
@@ -76,9 +76,9 @@ func TestWatchDomains(t *testing.T) {
 
 	require.NoError(t, os.RemoveAll(updateFile))
 
-	update := make(chan domains)
-	go watchDomains("gitlab.io", func(domains domains) {
-		update <- domains
+	update := make(chan domainMap)
+	go watchDomains("gitlab.io", func(dm domainMap) {
+		update <- dm
 	}, time.Microsecond*50)
 
 	defer os.Remove(updateFile)
@@ -95,12 +95,12 @@ func TestWatchDomains(t *testing.T) {
 	assert.NotNil(t, domains, "if the domains are updated after the timestamp change")
 }
 
-func recvTimeout(t *testing.T, ch <-chan domains) domains {
+func recvTimeout(t *testing.T, ch <-chan domainMap) domainMap {
 	timeout := 5 * time.Second
 
 	select {
-	case d := <-ch:
-		return d
+	case dm := <-ch:
+		return dm
 	case <-time.After(timeout):
 		t.Fatalf("timeout after %v waiting for domain update", timeout)
 		return nil
@@ -138,11 +138,11 @@ func BenchmarkReadGroups(b *testing.B) {
 	}
 
 	b.Run("ReadGroups", func(b *testing.B) {
-		var testDomains domains
+		var dm domainMap
 		for i := 0; i < 2; i++ {
-			testDomains = domains(make(map[string]*domain))
-			require.NoError(b, testDomains.ReadGroups("example.com"))
+			dm = make(domainMap)
+			require.NoError(b, dm.ReadGroups("example.com"))
 		}
-		b.Logf("found %d domains", len(testDomains))
+		b.Logf("found %d domains", len(dm))
 	})
 }