bump to go 1.11.5 (#79)

* bump to go 1.11.5

* housekeeping

.travis.yml

@@ -1,7 +1,6 @@
 language: go
 go:
- - 1.9.2
- - 1.10.3
+ - 1.11.5
  - tip
 
 matrix:

Makefile

@@ -21,3 +21,7 @@ test:
 .PHONY: vet
 vet:
  go vet ${GOPACKAGES}
+
+.PHONY: dofmt
+dofmt:
+ gofmt -l -s -w ${GOFILES}

README.md

@@ -10,15 +10,13 @@ of keys based on the gin attribute syntax and the comparison to literals or othe
 keys. These rules can be nested inside of AND, OR and NOT rules to enable the expression
 of complex relationships of values in etcd and the actions to be triggered when a set
 of conditions has been met. The engine watches etcd for updates and crawls the data tree
-at configurable intervals so that changes that occurred beyond the watch time scope are picked
-up and actions triggered by watches that initially failed can be retried without being lost.
-This library makes use of the IBM-Cloud/go-etcd-lock library to enable concurrent monitoring
-by multiple application instances without collisions--the first client to obtain the lock
-processes the change while the others quickly fail to acquire the lock and move on. A trigger
-callback function should update the model if the action is successful so it is not retriggered.
-Recurring actions, such as continuous polling, can be implemented with rules that reference
-nodes with TTLs such that the expiration of a node triggers a rule and the callback adds back
-a node with the same key and TTL.
+at configurable intervals. This library makes use of the IBM-Cloud/go-etcd-lock library 
+to enable concurrent monitoring by multiple application instances without collisions--the 
+first client to obtain the lock processes the change while the others quickly fail to acquire 
+the lock and move on. A trigger callback function should update the model if the action 
+is successful so it is not retriggered. Recurring actions, such as continuous polling, 
+can be implemented with rules that reference nodes with TTLs such that the expiration of 
+a node triggers a rule and the callback adds back a node with the same key and TTL.
 
 Import
 ------

rules/dynamic_rule.go

@@ -102,7 +102,7 @@ func processBooleanMap(keys []string, parent map[string]bool, value bool, proc f
 }
 
 func (krp *dynamicRule) getLeafRepresentationPatternMap() map[string][]string {
- out := map[string][]string{krp.rep: []string{}}
+ out := map[string][]string{krp.rep: {}}
  for _, pattern := range krp.patterns {
  out[krp.rep] = append(out[krp.rep], pattern)
  }

rules/dynamic_rule_test.go

@@ -246,7 +246,7 @@ func newExpandedEqualsLiteralRule(key string, value *string) DynamicRule {
  if err != nil {
  return nil
  }
- rules, _ := rule.Expand(map[string][]string{"region": []string{"us"}})
+ rules, _ := rule.Expand(map[string][]string{"region": {"us"}})
  return rules[0]
 }
 
@@ -255,7 +255,7 @@ func newExpandedEqualsRule(keys []string) DynamicRule {
  if err != nil {
  return nil
  }
- rules, _ := rule.Expand(map[string][]string{"region": []string{"us"}})
+ rules, _ := rule.Expand(map[string][]string{"region": {"us"}})
  return rules[0]
 }
 
@@ -358,7 +358,7 @@ func TestRuleSatisfied(t *testing.T) {
  true,
  map[string]string{
  "/emea/branch/parent/fef460923d2248bf99da87f8d4b1c363/child/child-home-fef460923d2248bf99da87f8d4b1c363-c1/attributes/location/value": "home",
- "/updater/emea/child/location/enabled":  "true",
+ "/updater/emea/child/location/enabled": "true",
  },
  },
  {
@@ -370,7 +370,7 @@ func TestRuleSatisfied(t *testing.T) {
  false,
  map[string]string{
  "/emea/branch/parent/fef460923d2248bf99da87f8d4b1c363/child/child-home-fef460923d2248bf99da87f8d4b1c363-c1/attributes/location/value": "home",
- "/updater/emea/child/location/enabled":  "true",
+ "/updater/emea/child/location/enabled": "true",
  },
  },
  }
@@ -465,53 +465,53 @@ func TestGetLeafRepresentationPatternMap(t *testing.T) {
  nil,
  func() (DynamicRule, error) { return NewEqualsLiteralRule("/:region/test", nil) },
  map[string][]string{
- "/:region/test = <nil>": []string{"/:region/test"},
+ "/:region/test = <nil>": {"/:region/test"},
  },
  },
  {
  nil,
  func() (DynamicRule, error) { return NewEqualsLiteralRule("/:region/test2", sTP("value")) },
  map[string][]string{
- "/:region/test2 = \"value\"": []string{"/:region/test2"},
+ "/:region/test2 = \"value\"": {"/:region/test2"},
  },
  },
  {
  func() DynamicRule { return NewAndRule(rules[0], rules[1]) },
  nil,
  map[string][]string{
- "/:region/test = <nil>": []string{"/:region/test"},
- "/:region/test2 = \"value\"": []string{"/:region/test2"},
+ "/:region/test = <nil>": {"/:region/test"},
+ "/:region/test2 = \"value\"": {"/:region/test2"},
  },
  },
  {
  func() DynamicRule { return NewOrRule(rules[0], rules[1]) },
  nil,
  map[string][]string{
- "/:region/test = <nil>": []string{"/:region/test"},
- "/:region/test2 = \"value\"": []string{"/:region/test2"},
+ "/:region/test = <nil>": {"/:region/test"},
+ "/:region/test2 = \"value\"": {"/:region/test2"},
  },
  },
  {
  func() DynamicRule { return NewOrRule(rules[2], rules[3]) },
  nil,
  map[string][]string{
- "/:region/test = <nil>": []string{"/:region/test"},
- "/:region/test2 = \"value\"": []string{"/:region/test2"},
+ "/:region/test = <nil>": {"/:region/test"},
+ "/:region/test2 = \"value\"": {"/:region/test2"},
  },
  },
  {
  func() DynamicRule { return NewNotRule(rules[4]) },
  nil,
  map[string][]string{
- "/:region/test = <nil>": []string{"/:region/test"},
- "/:region/test2 = \"value\"": []string{"/:region/test2"},
+ "/:region/test = <nil>": {"/:region/test"},
+ "/:region/test2 = \"value\"": {"/:region/test2"},
  },
  },
  {
  nil,
  func() (DynamicRule, error) { return NewEqualsRule([]string{"/:region/test", "/:region/test2"}) },
  map[string][]string{
- "/:region/test = /:region/test2": []string{"/:region/test", "/:region/test2"},
+ "/:region/test = /:region/test2": {"/:region/test", "/:region/test2"},
  },
  },
  }

rules/engine.go

@@ -10,7 +10,7 @@ import (
  "golang.org/x/net/context"
 )
 
-type stopable interface {
+type stoppable interface {
  stop()
  isStopped() bool
 }
@@ -35,9 +35,9 @@ type baseEngine struct {
  ruleLockTTLs map[int]int
  ruleMgr ruleManager
  stopped uint32
- crawlers []stopable
- watchers []stopable
- workers []stopable
+ crawlers []stoppable
+ watchers []stoppable
+ workers []stoppable
 }
 
 type channelCloser func()
@@ -141,9 +141,9 @@ func (e *baseEngine) Shutdown(ctx context.Context) error {
 
 func (e *baseEngine) stop() {
  e.logger.Debug("Stopping crawlers")
- stopStopables(e.crawlers)
+ stopstoppables(e.crawlers)
  e.logger.Debug("Stopping watchers")
- stopStopables(e.watchers)
+ stopstoppables(e.watchers)
  e.logger.Debug("Stopping workers")
  for _, worker := range e.workers {
  worker.stop()
@@ -153,19 +153,19 @@ func (e *baseEngine) stop() {
  // Ensure workers are stopped; the "stop" method is called again, but
  // that is idempotent. The workers' "stop" method must be called before
  // the channel is closed in order to avoid nil pointer dereference panics.
- stopStopables(e.workers)
+ stopstoppables(e.workers)
  atomicSet(&e.stopped, true)
  e.logger.Info("Engine stopped")
 }
 
-func stopStopables(stopables []stopable) {
- for _, s := range stopables {
+func stopstoppables(stoppables []stoppable) {
+ for _, s := range stoppables {
  s.stop()
  }
  allStopped := false
  for !allStopped {
  allStopped = true
- for _, s := range stopables {
+ for _, s := range stoppables {
  allStopped = allStopped && s.isStopped()
  }
  }

rules/matcher_test.go

@@ -32,7 +32,7 @@ func TestBasic(t *testing.T) {
  t.Fail()
  }
  prefixes := km.getPrefixesWithConstraints(map[string]constraint{
- "name": constraint{
+ "name": {
  prefix: "xy",
  chars: [][]rune{{'a', 'b'}, {'a', 'b'}},
  },

rules/options_test.go

@@ -24,10 +24,10 @@ func TestEngineOptions(t *testing.T) {
  assert.Equal(t, 1, opts.syncDelay)
  opts = makeEngineOptions(EngineConcurrency(10))
  assert.Equal(t, 10, opts.concurrency)
- keyExp1 := KeyExpansion(map[string][]string{"key1": []string{"val1"}, "key2": []string{"val2"}})
- keyExp2 := KeyExpansion(map[string][]string{"key2": []string{"val3"}, "key3": []string{"val4"}})
+ keyExp1 := KeyExpansion(map[string][]string{"key1": {"val1"}, "key2": {"val2"}})
+ keyExp2 := KeyExpansion(map[string][]string{"key2": {"val3"}, "key3": {"val4"}})
  opts = makeEngineOptions(keyExp1, keyExp2)
- assert.Equal(t, map[string][]string{"key1": []string{"val1"}, "key2": []string{"val3"}, "key3": []string{"val4"}}, opts.keyExpansion)
+ assert.Equal(t, map[string][]string{"key1": {"val1"}, "key2": {"val3"}, "key3": {"val4"}}, opts.keyExpansion)
  opts = makeEngineOptions(EngineSyncDelay(10))
  assert.Equal(t, 10, opts.syncDelay)
  opts = makeEngineOptions(EngineWatchTimeout(3))

rules/rule_manager_test.go

@@ -51,7 +51,7 @@ func TestCombineRuleData(t *testing.T) {
  expectedData []string
  }{
  {
- [][]string{[]string{"/a/b/c", "/x/y/z"}, []string{"/a/b/c"}},
+ [][]string{{"/a/b/c", "/x/y/z"}, {"/a/b/c"}},
  []string{"/a/b/c", "/x/y/z"},
  },
  }