You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficcontrol.apache.org by ne...@apache.org on 2016/10/28 20:15:54 UTC

[16/30] incubator-trafficcontrol git commit: Fix TM2 symbol names to be idiomatic

Fix TM2 symbol names to be idiomatic


Project: http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/commit/480f73cd
Tree: http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/tree/480f73cd
Diff: http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/diff/480f73cd

Branch: refs/heads/master
Commit: 480f73cd1464a64248942e061b17d91f9a814a8c
Parents: 6a6db0a
Author: Robert Butts <ro...@gmail.com>
Authored: Thu Oct 20 15:57:05 2016 -0600
Committer: Dave Neuman <ne...@apache.org>
Committed: Fri Oct 28 14:00:36 2016 -0600

----------------------------------------------------------------------
 .../experimental/traffic_monitor/cache/cache.go | 32 +++++------
 .../traffic_monitor/config/config.go            | 14 ++---
 .../traffic_monitor/health/cache_health.go      | 10 ++--
 .../traffic_monitor/manager/datarequest.go      | 10 ++--
 .../traffic_monitor/manager/healthresult.go     | 20 +++----
 .../traffic_monitor/manager/manager.go          |  2 +-
 .../traffic_monitor/manager/monitorconfig.go    | 24 ++++-----
 .../traffic_monitor/manager/peer.go             |  2 +-
 .../traffic_monitor/manager/polledcaches.go     |  2 +-
 .../traffic_monitor/manager/stathistory.go      | 24 ++++-----
 .../traffic_monitor/peer/crstates.go            | 56 ++++++++++----------
 .../experimental/traffic_monitor/peer/peer.go   |  8 +--
 12 files changed, 102 insertions(+), 102 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/cache/cache.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/cache/cache.go b/traffic_monitor/experimental/traffic_monitor/cache/cache.go
index 20eb2a5..f679cf5 100644
--- a/traffic_monitor/experimental/traffic_monitor/cache/cache.go
+++ b/traffic_monitor/experimental/traffic_monitor/cache/cache.go
@@ -6,8 +6,8 @@ import (
 	"github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/common/log"
 	dsdata "github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/deliveryservicedata"
 	"github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/enum"
-	"github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/srvhttp"
 	"github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/peer"
+	"github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/srvhttp"
 	todata "github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/trafficopsdata"
 	"io"
 	"net/url"
@@ -35,8 +35,8 @@ func NewPrecomputeHandler(toData todata.TODataThreadsafe, peerStates peer.CRStat
 	return Handler{ResultChannel: make(chan Result), MultipleSpaceRegex: regexp.MustCompile(" +"), ToData: &toData, PeerStates: &peerStates}
 }
 
-func (h Handler) Precompute() bool {
-	return h.ToData != nil && h.PeerStates != nil
+func (handler Handler) Precompute() bool {
+	return handler.ToData != nil && handler.PeerStates != nil
 }
 
 type PrecomputedData struct {
@@ -48,7 +48,7 @@ type PrecomputedData struct {
 }
 
 type Result struct {
-	Id        enum.CacheName
+	ID        enum.CacheName
 	Available bool
 	Error     error
 	Astats    Astats
@@ -126,12 +126,12 @@ func StatsMarshall(statHistory map[enum.CacheName][]Result, filter Filter, param
 	return json.Marshal(stats)
 }
 
-func (handler Handler) Handle(id string, r io.Reader, err error, pollId uint64, pollFinished chan<- uint64) {
-	log.Debugf("poll %v %v handle start\n", pollId, time.Now())
+func (handler Handler) Handle(id string, r io.Reader, err error, pollID uint64, pollFinished chan<- uint64) {
+	log.Debugf("poll %v %v handle start\n", pollID, time.Now())
 	result := Result{
-		Id:           enum.CacheName(id),
+		ID:           enum.CacheName(id),
 		Time:         time.Now(), // TODO change this to be computed the instant we get the result back, to minimise inaccuracy
-		PollID:       pollId,
+		PollID:       pollID,
 		PollFinished: pollFinished,
 	}
 
@@ -166,7 +166,7 @@ func (handler Handler) Handle(id string, r io.Reader, err error, pollId uint64,
 		log.Warnf("addkbps %s inf.speed empty\n", id)
 	}
 
-	log.Debugf("poll %v %v handle decode end\n", pollId, time.Now())
+	log.Debugf("poll %v %v handle decode end\n", pollID, time.Now())
 
 	if err != nil {
 		result.Error = err
@@ -176,13 +176,13 @@ func (handler Handler) Handle(id string, r io.Reader, err error, pollId uint64,
 	}
 
 	if handler.Precompute() {
-		log.Debugf("poll %v %v handle precompute start\n", pollId, time.Now())
+		log.Debugf("poll %v %v handle precompute start\n", pollID, time.Now())
 		result = handler.precompute(result)
-		log.Debugf("poll %v %v handle precompute end\n", pollId, time.Now())
+		log.Debugf("poll %v %v handle precompute end\n", pollID, time.Now())
 	}
-	log.Debugf("poll %v %v handle write start\n", pollId, time.Now())
+	log.Debugf("poll %v %v handle write start\n", pollID, time.Now())
 	handler.ResultChannel <- result
-	log.Debugf("poll %v %v handle end\n", pollId, time.Now())
+	log.Debugf("poll %v %v handle end\n", pollID, time.Now())
 }
 
 // outBytes takes the proc.net.dev string, and the interface name, and returns the bytes field
@@ -218,7 +218,7 @@ func (handler Handler) precompute(result Result) Result {
 	var err error
 	if result.PrecomputedData.OutBytes, err = outBytes(result.Astats.System.ProcNetDev, result.Astats.System.InfName, handler.MultipleSpaceRegex); err != nil {
 		result.PrecomputedData.OutBytes = 0
-		log.Errorf("addkbps %s handle precomputing outbytes '%v'\n", result.Id, err)
+		log.Errorf("addkbps %s handle precomputing outbytes '%v'\n", result.ID, err)
 	}
 
 	kbpsInMbps := int64(1000)
@@ -226,9 +226,9 @@ func (handler Handler) precompute(result Result) Result {
 
 	for stat, value := range result.Astats.Ats {
 		var err error
-		stats, err = processStat(result.Id, stats, todata, stat, value, result.Time)
+		stats, err = processStat(result.ID, stats, todata, stat, value, result.Time)
 		if err != nil && err != dsdata.ErrNotProcessedStat {
-			log.Errorf("precomputing cache %v stat %v value %v error %v", result.Id, stat, value, err)
+			log.Errorf("precomputing cache %v stat %v value %v error %v", result.ID, stat, value, err)
 			result.PrecomputedData.Errors = append(result.PrecomputedData.Errors, err)
 		}
 	}

http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/config/config.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/config/config.go b/traffic_monitor/experimental/traffic_monitor/config/config.go
index 316651a..f8bbe30 100644
--- a/traffic_monitor/experimental/traffic_monitor/config/config.go
+++ b/traffic_monitor/experimental/traffic_monitor/config/config.go
@@ -16,7 +16,7 @@ type Config struct {
 	CacheHealthPollingInterval   time.Duration `json:"-"`
 	CacheStatPollingInterval     time.Duration `json:"-"`
 	MonitorConfigPollingInterval time.Duration `json:"-"`
-	HttpTimeout                  time.Duration `json:"-"`
+	HTTPTimeout                  time.Duration `json:"-"`
 	PeerPollingInterval          time.Duration `json:"-"`
 	MaxEvents                    uint64        `json:"max_events"`
 	MaxStatHistory               uint64        `json:"max_stat_history"`
@@ -35,7 +35,7 @@ var DefaultConfig = Config{
 	CacheHealthPollingInterval:   6 * time.Second,
 	CacheStatPollingInterval:     6 * time.Second,
 	MonitorConfigPollingInterval: 5 * time.Second,
-	HttpTimeout:                  2 * time.Second,
+	HTTPTimeout:                  2 * time.Second,
 	PeerPollingInterval:          5 * time.Second,
 	MaxEvents:                    200,
 	MaxStatHistory:               5,
@@ -57,7 +57,7 @@ func (c *Config) MarshalJSON() ([]byte, error) {
 		CacheHealthPollingIntervalMs   uint64 `json:"cache_health_polling_interval_ms"`
 		CacheStatPollingIntervalMs     uint64 `json:"cache_stat_polling_interval_ms"`
 		MonitorConfigPollingIntervalMs uint64 `json:"monitor_config_polling_interval_ms"`
-		HttpTimeoutMs                  uint64 `json:"http_timeout_ms"`
+		HTTPTimeoutMS                  uint64 `json:"http_timeout_ms"`
 		PeerPollingIntervalMs          uint64 `json:"peer_polling_interval_ms"`
 		HealthFlushIntervalMs          uint64 `json:"health_flush_interval_ms"`
 		StatFlushIntervalMs            uint64 `json:"stat_flush_interval_ms"`
@@ -68,7 +68,7 @@ func (c *Config) MarshalJSON() ([]byte, error) {
 		CacheHealthPollingIntervalMs:   uint64(c.CacheHealthPollingInterval / time.Millisecond),
 		CacheStatPollingIntervalMs:     uint64(c.CacheStatPollingInterval / time.Millisecond),
 		MonitorConfigPollingIntervalMs: uint64(c.MonitorConfigPollingInterval / time.Millisecond),
-		HttpTimeoutMs:                  uint64(c.HttpTimeout / time.Millisecond),
+		HTTPTimeoutMS:                  uint64(c.HTTPTimeout / time.Millisecond),
 		PeerPollingIntervalMs:          uint64(c.PeerPollingInterval / time.Millisecond),
 		HealthFlushIntervalMs:          uint64(c.HealthFlushInterval / time.Millisecond),
 		StatFlushIntervalMs:            uint64(c.StatFlushInterval / time.Millisecond),
@@ -82,7 +82,7 @@ func (c *Config) UnmarshalJSON(data []byte) error {
 		CacheHealthPollingIntervalMs   *uint64 `json:"cache_health_polling_interval_ms"`
 		CacheStatPollingIntervalMs     *uint64 `json:"cache_stat_polling_interval_ms"`
 		MonitorConfigPollingIntervalMs *uint64 `json:"monitor_config_polling_interval_ms"`
-		HttpTimeoutMs                  *uint64 `json:"http_timeout_ms"`
+		HTTPTimeoutMS                  *uint64 `json:"http_timeout_ms"`
 		PeerPollingIntervalMs          *uint64 `json:"peer_polling_interval_ms"`
 		HealthFlushIntervalMs          *uint64 `json:"health_flush_interval_ms"`
 		StatFlushIntervalMs            *uint64 `json:"stat_flush_interval_ms"`
@@ -105,8 +105,8 @@ func (c *Config) UnmarshalJSON(data []byte) error {
 	if aux.MonitorConfigPollingIntervalMs != nil {
 		c.MonitorConfigPollingInterval = time.Duration(*aux.MonitorConfigPollingIntervalMs) * time.Millisecond
 	}
-	if aux.HttpTimeoutMs != nil {
-		c.HttpTimeout = time.Duration(*aux.HttpTimeoutMs) * time.Millisecond
+	if aux.HTTPTimeoutMS != nil {
+		c.HTTPTimeout = time.Duration(*aux.HTTPTimeoutMS) * time.Millisecond
 	}
 	if aux.PeerPollingIntervalMs != nil {
 		c.PeerPollingInterval = time.Duration(*aux.PeerPollingIntervalMs) * time.Millisecond

http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/health/cache_health.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/health/cache_health.go b/traffic_monitor/experimental/traffic_monitor/health/cache_health.go
index cf1acff..11e746e 100644
--- a/traffic_monitor/experimental/traffic_monitor/health/cache_health.go
+++ b/traffic_monitor/experimental/traffic_monitor/health/cache_health.go
@@ -32,7 +32,7 @@ func GetVitals(newResult *cache.Result, prevResult *cache.Result, mc *traffic_op
 		}
 		newResult.Vitals.LoadAvg = oneMinAvg
 	} else {
-		setError(newResult, fmt.Errorf("Can't make sense of '%s' as a load average for %s", newResult.Astats.System.ProcLoadavg, newResult.Id))
+		setError(newResult, fmt.Errorf("Can't make sense of '%s' as a load average for %s", newResult.Astats.System.ProcLoadavg, newResult.ID))
 		return
 	}
 
@@ -68,14 +68,14 @@ func GetVitals(newResult *cache.Result, prevResult *cache.Result, mc *traffic_op
 	// inf.speed -- value looks like "10000" (without the quotes) so it is in Mbps.
 	// TODO JvD: Should we really be running this code every second for every cache polled????? I don't think so.
 	interfaceBandwidth := newResult.Astats.System.InfSpeed
-	newResult.Vitals.MaxKbpsOut = int64(interfaceBandwidth)*1000 - mc.Profile[mc.TrafficServer[string(newResult.Id)].Profile].Parameters.MinFreeKbps
+	newResult.Vitals.MaxKbpsOut = int64(interfaceBandwidth)*1000 - mc.Profile[mc.TrafficServer[string(newResult.ID)].Profile].Parameters.MinFreeKbps
 
 	// log.Infoln(newResult.Id, "BytesOut", newResult.Vitals.BytesOut, "BytesIn", newResult.Vitals.BytesIn, "Kbps", newResult.Vitals.KbpsOut, "max", newResult.Vitals.MaxKbpsOut)
 }
 
 // EvalCache returns whether the given cache should be marked available, and a string describing why
 func EvalCache(result cache.Result, mc *traffic_ops.TrafficMonitorConfigMap) (bool, string) {
-	status := mc.TrafficServer[string(result.Id)].Status
+	status := mc.TrafficServer[string(result.ID)].Status
 	switch {
 	case status == "ADMIN_DOWN":
 		return false, "set to ADMIN_DOWN"
@@ -85,8 +85,8 @@ func EvalCache(result cache.Result, mc *traffic_ops.TrafficMonitorConfigMap) (bo
 		return true, "set to ONLINE"
 	case result.Error != nil:
 		return false, fmt.Sprintf("error: %v", result.Error)
-	case result.Vitals.LoadAvg > mc.Profile[mc.TrafficServer[string(result.Id)].Profile].Parameters.HealthThresholdLoadAvg:
-		return false, fmt.Sprintf("load average %f exceeds threshold %f", result.Vitals.LoadAvg, mc.Profile[mc.TrafficServer[string(result.Id)].Profile].Parameters.HealthThresholdLoadAvg)
+	case result.Vitals.LoadAvg > mc.Profile[mc.TrafficServer[string(result.ID)].Profile].Parameters.HealthThresholdLoadAvg:
+		return false, fmt.Sprintf("load average %f exceeds threshold %f", result.Vitals.LoadAvg, mc.Profile[mc.TrafficServer[string(result.ID)].Profile].Parameters.HealthThresholdLoadAvg)
 	case result.Vitals.MaxKbpsOut < result.Vitals.KbpsOut:
 		return false, fmt.Sprintf("%dkbps exceeds max %dkbps", result.Vitals.KbpsOut, result.Vitals.MaxKbpsOut)
 	default:

http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/manager/datarequest.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/manager/datarequest.go b/traffic_monitor/experimental/traffic_monitor/manager/datarequest.go
index 52d2d17..e754f89 100644
--- a/traffic_monitor/experimental/traffic_monitor/manager/datarequest.go
+++ b/traffic_monitor/experimental/traffic_monitor/manager/datarequest.go
@@ -16,8 +16,8 @@ import (
 	ds "github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/deliveryservice"
 	dsdata "github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/deliveryservicedata"
 	"github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/enum"
-	"github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/srvhttp"
 	"github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/peer"
+	"github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/srvhttp"
 	todata "github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/trafficopsdata"
 	towrap "github.com/apache/incubator-trafficcontrol/traffic_monitor/experimental/traffic_monitor/trafficopswrapper"
 )
@@ -30,7 +30,7 @@ type CacheState struct {
 	Value bool `json:"value"`
 }
 
-type ApiPeerStates struct {
+type APIPeerStates struct {
 	srvhttp.CommonAPIData
 	Peers map[enum.TrafficMonitorName]map[enum.CacheName][]CacheState `json:"peers"`
 }
@@ -487,7 +487,7 @@ func DataRequest(
 			return []byte(err.Error()), http.StatusBadRequest
 		}
 
-		body, err = json.Marshal(createApiPeerStates(peerStates.Get(), filter, req.Parameters))
+		body, err = json.Marshal(createAPIPeerStates(peerStates.Get(), filter, req.Parameters))
 		return commonReturn(body, err)
 	case srvhttp.StatSummary:
 		return nil, http.StatusNotImplemented
@@ -671,8 +671,8 @@ func cacheAvailableCount(caches map[enum.CacheName]peer.IsAvailable) int {
 	return len(caches) - cacheDownCount(caches)
 }
 
-func createApiPeerStates(peerStates map[enum.TrafficMonitorName]peer.Crstates, filter *PeerStateFilter, params url.Values) ApiPeerStates {
-	apiPeerStates := ApiPeerStates{
+func createAPIPeerStates(peerStates map[enum.TrafficMonitorName]peer.Crstates, filter *PeerStateFilter, params url.Values) APIPeerStates {
+	apiPeerStates := APIPeerStates{
 		CommonAPIData: srvhttp.GetCommonAPIData(params, time.Now()),
 		Peers:         map[enum.TrafficMonitorName]map[enum.CacheName][]CacheState{},
 	}

http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/manager/healthresult.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/manager/healthresult.go b/traffic_monitor/experimental/traffic_monitor/manager/healthresult.go
index dda4d27..5074f26 100644
--- a/traffic_monitor/experimental/traffic_monitor/manager/healthresult.go
+++ b/traffic_monitor/experimental/traffic_monitor/manager/healthresult.go
@@ -189,7 +189,7 @@ func processHealthResult(
 		log.Debugf("poll %v %v healthresultman start\n", healthResult.PollID, time.Now())
 		fetchCount.Inc()
 		var prevResult cache.Result
-		healthResultHistory := healthHistory[enum.CacheName(healthResult.Id)]
+		healthResultHistory := healthHistory[enum.CacheName(healthResult.ID)]
 		if len(healthResultHistory) != 0 {
 			prevResult = healthResultHistory[len(healthResultHistory)-1]
 		}
@@ -198,16 +198,16 @@ func processHealthResult(
 			health.GetVitals(&healthResult, &prevResult, &monitorConfigCopy)
 		}
 
-		healthHistory[enum.CacheName(healthResult.Id)] = pruneHistory(append(healthHistory[enum.CacheName(healthResult.Id)], healthResult), cfg.MaxHealthHistory)
+		healthHistory[enum.CacheName(healthResult.ID)] = pruneHistory(append(healthHistory[enum.CacheName(healthResult.ID)], healthResult), cfg.MaxHealthHistory)
 
 		isAvailable, whyAvailable := health.EvalCache(healthResult, &monitorConfigCopy)
-		if localStates.Get().Caches[healthResult.Id].IsAvailable != isAvailable {
-			log.Infof("Changing state for %s was: %t now: %t because %s error: %v", healthResult.Id, prevResult.Available, isAvailable, whyAvailable, healthResult.Error)
-			events.Add(Event{Time: time.Now().Unix(), Description: whyAvailable, Name: healthResult.Id, Hostname: healthResult.Id, Type: toDataCopy.ServerTypes[healthResult.Id].String(), Available: isAvailable})
+		if localStates.Get().Caches[healthResult.ID].IsAvailable != isAvailable {
+			log.Infof("Changing state for %s was: %t now: %t because %s error: %v", healthResult.ID, prevResult.Available, isAvailable, whyAvailable, healthResult.Error)
+			events.Add(Event{Time: time.Now().Unix(), Description: whyAvailable, Name: healthResult.ID, Hostname: healthResult.ID, Type: toDataCopy.ServerTypes[healthResult.ID].String(), Available: isAvailable})
 		}
 
-		localCacheStatus[healthResult.Id] = CacheAvailableStatus{Available: isAvailable, Status: monitorConfigCopy.TrafficServer[string(healthResult.Id)].Status} // TODO move within localStates?
-		localStates.SetCache(healthResult.Id, peer.IsAvailable{IsAvailable: isAvailable})
+		localCacheStatus[healthResult.ID] = CacheAvailableStatus{Available: isAvailable, Status: monitorConfigCopy.TrafficServer[string(healthResult.ID)].Status} // TODO move within localStates?
+		localStates.SetCache(healthResult.ID, peer.IsAvailable{IsAvailable: isAvailable})
 		log.Debugf("poll %v %v calculateDeliveryServiceState start\n", healthResult.PollID, time.Now())
 		calculateDeliveryServiceState(toDataCopy.DeliveryServiceServers, localStates)
 		log.Debugf("poll %v %v calculateDeliveryServiceState end\n", healthResult.PollID, time.Now())
@@ -217,11 +217,11 @@ func processHealthResult(
 
 	lastHealthDurations := lastHealthDurationsThreadsafe.Get().Copy()
 	for _, healthResult := range results {
-		if lastHealthStart, ok := lastHealthEndTimes[enum.CacheName(healthResult.Id)]; ok {
+		if lastHealthStart, ok := lastHealthEndTimes[enum.CacheName(healthResult.ID)]; ok {
 			d := time.Since(lastHealthStart)
-			lastHealthDurations[enum.CacheName(healthResult.Id)] = d
+			lastHealthDurations[enum.CacheName(healthResult.ID)] = d
 		}
-		lastHealthEndTimes[enum.CacheName(healthResult.Id)] = time.Now()
+		lastHealthEndTimes[enum.CacheName(healthResult.ID)] = time.Now()
 
 		log.Debugf("poll %v %v finish\n", healthResult.PollID, time.Now())
 		healthResult.PollFinished <- healthResult.PollID

http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/manager/manager.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/manager/manager.go b/traffic_monitor/experimental/traffic_monitor/manager/manager.go
index fe87d90..ea4b106 100644
--- a/traffic_monitor/experimental/traffic_monitor/manager/manager.go
+++ b/traffic_monitor/experimental/traffic_monitor/manager/manager.go
@@ -41,7 +41,7 @@ func Start(opsConfigFile string, cfg config.Config, staticAppData StaticAppData)
 
 	// TODO investigate whether a unique client per cache to be polled is faster
 	sharedClient := &http.Client{
-		Timeout:   cfg.HttpTimeout,
+		Timeout:   cfg.HTTPTimeout,
 		Transport: &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}},
 	}
 

http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/manager/monitorconfig.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/manager/monitorconfig.go b/traffic_monitor/experimental/traffic_monitor/manager/monitorconfig.go
index 2e39771..fa24f04 100644
--- a/traffic_monitor/experimental/traffic_monitor/manager/monitorconfig.go
+++ b/traffic_monitor/experimental/traffic_monitor/manager/monitorconfig.go
@@ -67,9 +67,9 @@ func (t *TrafficMonitorConfigMapThreadsafe) Set(c to.TrafficMonitorConfigMap) {
 func StartMonitorConfigManager(
 	monitorConfigPollChan <-chan to.TrafficMonitorConfigMap,
 	localStates peer.CRStatesThreadsafe,
-	statUrlSubscriber chan<- poller.HttpPollerConfig,
-	healthUrlSubscriber chan<- poller.HttpPollerConfig,
-	peerUrlSubscriber chan<- poller.HttpPollerConfig,
+	statURLSubscriber chan<- poller.HttpPollerConfig,
+	healthURLSubscriber chan<- poller.HttpPollerConfig,
+	peerURLSubscriber chan<- poller.HttpPollerConfig,
 	cachesChangeSubscriber chan<- struct{},
 	cfg config.Config,
 	staticAppData StaticAppData,
@@ -78,9 +78,9 @@ func StartMonitorConfigManager(
 	go monitorConfigListen(monitorConfig,
 		monitorConfigPollChan,
 		localStates,
-		statUrlSubscriber,
-		healthUrlSubscriber,
-		peerUrlSubscriber,
+		statURLSubscriber,
+		healthURLSubscriber,
+		peerURLSubscriber,
 		cachesChangeSubscriber,
 		cfg,
 		staticAppData,
@@ -94,9 +94,9 @@ func monitorConfigListen(
 	monitorConfigTS TrafficMonitorConfigMapThreadsafe,
 	monitorConfigPollChan <-chan to.TrafficMonitorConfigMap,
 	localStates peer.CRStatesThreadsafe,
-	statUrlSubscriber chan<- poller.HttpPollerConfig,
-	healthUrlSubscriber chan<- poller.HttpPollerConfig,
-	peerUrlSubscriber chan<- poller.HttpPollerConfig,
+	statURLSubscriber chan<- poller.HttpPollerConfig,
+	healthURLSubscriber chan<- poller.HttpPollerConfig,
+	peerURLSubscriber chan<- poller.HttpPollerConfig,
 	cachesChangeSubscriber chan<- struct{},
 	cfg config.Config,
 	staticAppData StaticAppData,
@@ -152,9 +152,9 @@ func monitorConfigListen(
 			peerUrls[srv.HostName] = url
 		}
 
-		statUrlSubscriber <- poller.HttpPollerConfig{Urls: statUrls, Interval: cfg.CacheStatPollingInterval}
-		healthUrlSubscriber <- poller.HttpPollerConfig{Urls: healthUrls, Interval: cfg.CacheHealthPollingInterval}
-		peerUrlSubscriber <- poller.HttpPollerConfig{Urls: peerUrls, Interval: cfg.PeerPollingInterval}
+		statURLSubscriber <- poller.HttpPollerConfig{Urls: statUrls, Interval: cfg.CacheStatPollingInterval}
+		healthURLSubscriber <- poller.HttpPollerConfig{Urls: healthUrls, Interval: cfg.CacheHealthPollingInterval}
+		peerURLSubscriber <- poller.HttpPollerConfig{Urls: peerUrls, Interval: cfg.PeerPollingInterval}
 
 		for cacheName := range localStates.GetCaches() {
 			if _, exists := monitorConfig.TrafficServer[string(cacheName)]; !exists {

http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/manager/peer.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/manager/peer.go b/traffic_monitor/experimental/traffic_monitor/manager/peer.go
index 111ffc6..2bca917 100644
--- a/traffic_monitor/experimental/traffic_monitor/manager/peer.go
+++ b/traffic_monitor/experimental/traffic_monitor/manager/peer.go
@@ -17,7 +17,7 @@ func StartPeerManager(
 	combinedStates := peer.NewCRStatesThreadsafe()
 	go func() {
 		for crStatesResult := range peerChan {
-			peerStates.Set(crStatesResult.Id, crStatesResult.PeerStats)
+			peerStates.Set(crStatesResult.ID, crStatesResult.PeerStats)
 			combinedStates.Set(combineCrStates(peerStates.Get(), localStates.Get()))
 			crStatesResult.PollFinished <- crStatesResult.PollID
 		}

http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/manager/polledcaches.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/manager/polledcaches.go b/traffic_monitor/experimental/traffic_monitor/manager/polledcaches.go
index 48e4f71..9b66a8d 100644
--- a/traffic_monitor/experimental/traffic_monitor/manager/polledcaches.go
+++ b/traffic_monitor/experimental/traffic_monitor/manager/polledcaches.go
@@ -96,7 +96,7 @@ func (t *UnpolledCachesThreadsafe) SetPolled(results []cache.Result, lastStatsTh
 	for cache, _ := range unpolledCaches {
 	innerLoop:
 		for _, result := range results {
-			if result.Id != cache {
+			if result.ID != cache {
 				continue
 			}
 			if !result.Available || len(result.Errors) > 0 {

http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/manager/stathistory.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/manager/stathistory.go b/traffic_monitor/experimental/traffic_monitor/manager/stathistory.go
index 9cf0fdc..ac1c7a6 100644
--- a/traffic_monitor/experimental/traffic_monitor/manager/stathistory.go
+++ b/traffic_monitor/experimental/traffic_monitor/manager/stathistory.go
@@ -47,17 +47,17 @@ func NewStatHistoryThreadsafe(maxHistory uint64) StatHistoryThreadsafe {
 }
 
 // Get returns the StatHistory. Callers MUST NOT modify. If mutation is necessary, call StatHistory.Copy()
-func (t *StatHistoryThreadsafe) Get() StatHistory {
-	t.m.RLock()
-	defer t.m.RUnlock()
-	return *t.statHistory
+func (h *StatHistoryThreadsafe) Get() StatHistory {
+	h.m.RLock()
+	defer h.m.RUnlock()
+	return *h.statHistory
 }
 
 // Set sets the internal StatHistory. This is only safe for one thread of execution. This MUST NOT be called from multiple threads.
-func (t *StatHistoryThreadsafe) Set(v StatHistory) {
-	t.m.Lock()
-	*t.statHistory = v
-	t.m.Unlock()
+func (h *StatHistoryThreadsafe) Set(v StatHistory) {
+	h.m.Lock()
+	*h.statHistory = v
+	h.m.Unlock()
 }
 
 func pruneHistory(history []cache.Result, limit uint64) []cache.Result {
@@ -151,7 +151,7 @@ func processStatResults(
 	maxStats := statHistoryThreadsafe.Max()
 	for _, result := range results {
 		// TODO determine if we want to add results with errors, or just print the errors now and don't add them.
-		statHistory[enum.CacheName(result.Id)] = pruneHistory(append(statHistory[enum.CacheName(result.Id)], result), maxStats)
+		statHistory[enum.CacheName(result.ID)] = pruneHistory(append(statHistory[enum.CacheName(result.ID)], result), maxStats)
 	}
 	statHistoryThreadsafe.Set(statHistory)
 
@@ -176,11 +176,11 @@ func processStatResults(
 	endTime := time.Now()
 	lastStatDurations := lastStatDurationsThreadsafe.Get().Copy()
 	for _, result := range results {
-		if lastStatStart, ok := lastStatEndTimes[enum.CacheName(result.Id)]; ok {
+		if lastStatStart, ok := lastStatEndTimes[enum.CacheName(result.ID)]; ok {
 			d := time.Since(lastStatStart)
-			lastStatDurations[enum.CacheName(result.Id)] = d
+			lastStatDurations[enum.CacheName(result.ID)] = d
 		}
-		lastStatEndTimes[enum.CacheName(result.Id)] = endTime
+		lastStatEndTimes[enum.CacheName(result.ID)] = endTime
 
 		// log.Debugf("poll %v %v statfinish\n", result.PollID, endTime)
 		result.PollFinished <- result.PollID

http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/peer/crstates.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/peer/crstates.go b/traffic_monitor/experimental/traffic_monitor/peer/crstates.go
index 6f4bda7..1aaf314 100644
--- a/traffic_monitor/experimental/traffic_monitor/peer/crstates.go
+++ b/traffic_monitor/experimental/traffic_monitor/peer/crstates.go
@@ -110,40 +110,40 @@ func (t *CRStatesThreadsafe) GetDeliveryService(name enum.DeliveryServiceName) D
 	return t.crStates.Deliveryservice[name]
 }
 
-func (o *CRStatesThreadsafe) Set(newCRStates Crstates) {
-	o.m.Lock()
-	*o.crStates = newCRStates
-	o.m.Unlock()
+func (t *CRStatesThreadsafe) Set(newCRStates Crstates) {
+	t.m.Lock()
+	*t.crStates = newCRStates
+	t.m.Unlock()
 }
 
-func (o *CRStatesThreadsafe) SetCache(cacheName enum.CacheName, available IsAvailable) {
-	o.m.Lock()
-	o.crStates.Caches[cacheName] = available
-	o.m.Unlock()
+func (t *CRStatesThreadsafe) SetCache(cacheName enum.CacheName, available IsAvailable) {
+	t.m.Lock()
+	t.crStates.Caches[cacheName] = available
+	t.m.Unlock()
 }
 
-func (o *CRStatesThreadsafe) DeleteCache(name enum.CacheName) {
-	o.m.Lock()
-	delete(o.crStates.Caches, name)
-	o.m.Unlock()
+func (t *CRStatesThreadsafe) DeleteCache(name enum.CacheName) {
+	t.m.Lock()
+	delete(t.crStates.Caches, name)
+	t.m.Unlock()
 }
 
-func (o *CRStatesThreadsafe) SetDeliveryService(name enum.DeliveryServiceName, ds Deliveryservice) {
-	o.m.Lock()
-	o.crStates.Deliveryservice[name] = ds
-	o.m.Unlock()
+func (t *CRStatesThreadsafe) SetDeliveryService(name enum.DeliveryServiceName, ds Deliveryservice) {
+	t.m.Lock()
+	t.crStates.Deliveryservice[name] = ds
+	t.m.Unlock()
 }
 
-func (o *CRStatesThreadsafe) SetDeliveryServices(deliveryServices map[enum.DeliveryServiceName]Deliveryservice) {
-	o.m.Lock()
-	o.crStates.Deliveryservice = deliveryServices
-	o.m.Unlock()
+func (t *CRStatesThreadsafe) SetDeliveryServices(deliveryServices map[enum.DeliveryServiceName]Deliveryservice) {
+	t.m.Lock()
+	t.crStates.Deliveryservice = deliveryServices
+	t.m.Unlock()
 }
 
-func (o *CRStatesThreadsafe) DeleteDeliveryService(name enum.DeliveryServiceName) {
-	o.m.Lock()
-	delete(o.crStates.Deliveryservice, name)
-	o.m.Unlock()
+func (t *CRStatesThreadsafe) DeleteDeliveryService(name enum.DeliveryServiceName) {
+	t.m.Lock()
+	delete(t.crStates.Deliveryservice, name)
+	t.m.Unlock()
 }
 
 // This could be made lock-free, if the performance was necessary
@@ -166,8 +166,8 @@ func (t *CRStatesPeersThreadsafe) Get() map[enum.TrafficMonitorName]Crstates {
 	return m
 }
 
-func (o *CRStatesPeersThreadsafe) Set(peerName enum.TrafficMonitorName, peerState Crstates) {
-	o.m.Lock()
-	o.crStates[peerName] = peerState
-	o.m.Unlock()
+func (t *CRStatesPeersThreadsafe) Set(peerName enum.TrafficMonitorName, peerState Crstates) {
+	t.m.Lock()
+	t.crStates[peerName] = peerState
+	t.m.Unlock()
 }

http://git-wip-us.apache.org/repos/asf/incubator-trafficcontrol/blob/480f73cd/traffic_monitor/experimental/traffic_monitor/peer/peer.go
----------------------------------------------------------------------
diff --git a/traffic_monitor/experimental/traffic_monitor/peer/peer.go b/traffic_monitor/experimental/traffic_monitor/peer/peer.go
index f1788d9..ae898eb 100644
--- a/traffic_monitor/experimental/traffic_monitor/peer/peer.go
+++ b/traffic_monitor/experimental/traffic_monitor/peer/peer.go
@@ -17,7 +17,7 @@ func NewHandler() Handler {
 }
 
 type Result struct {
-	Id           enum.TrafficMonitorName
+	ID           enum.TrafficMonitorName
 	Available    bool
 	Errors       []error
 	PeerStats    Crstates
@@ -25,12 +25,12 @@ type Result struct {
 	PollFinished chan<- uint64
 }
 
-func (handler Handler) Handle(id string, r io.Reader, err error, pollId uint64, pollFinished chan<- uint64) {
+func (handler Handler) Handle(id string, r io.Reader, err error, pollID uint64, pollFinished chan<- uint64) {
 	result := Result{
-		Id:           enum.TrafficMonitorName(id),
+		ID:           enum.TrafficMonitorName(id),
 		Available:    false,
 		Errors:       []error{},
-		PollID:       pollId,
+		PollID:       pollID,
 		PollFinished: pollFinished,
 	}