Add golint to travis

.travis.yml

@@ -19,11 +19,14 @@ before_install:
 # The dependencies have already been vendored by `dep` so
 # we don't need to fetch them.
 install:
-  -
+  - go get -u golang.org/x/lint/golint
 
 script:
+- go vet ./pkg/...
+- golint -set_exit_status ./pkg/...
 - TRACE=1 ./test.sh
 
+
 # TBD. Suppressing for now.
 notifications:
   email: false

example/main.go

@@ -37,15 +37,15 @@ func main() {
 	flag.Parse()
 	logf.SetLogger(logf.ZapLogger(false))
 
-	// Setup a ControllerManager
-	manager, err := controller.NewControllerManager(controller.ControllerManagerArgs{})
+	// Setup a Manager
+	manager, err := controller.NewManager(controller.ManagerArgs{})
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	// Setup a new controller to Reconcile ReplicaSets
 	c, err := manager.NewController(
-		controller.ControllerArgs{Name: "foo-controller", MaxConcurrentReconciles: 1},
+		controller.Args{Name: "foo-controller", MaxConcurrentReconciles: 1},
 		&reconcileReplicaSet{client: manager.GetClient()},
 	)
 	if err != nil {
@@ -81,18 +81,18 @@ type reconcileReplicaSet struct {
 // Implement reconcile.reconcile so the controller can reconcile objects
 var _ reconcile.Reconcile = &reconcileReplicaSet{}
 
-func (r *reconcileReplicaSet) Reconcile(request reconcile.ReconcileRequest) (reconcile.ReconcileResult, error) {
+func (r *reconcileReplicaSet) Reconcile(request reconcile.Request) (reconcile.Result, error) {
 	// Fetch the ReplicaSet from the cache
 	rs := &appsv1.ReplicaSet{}
 	err := r.client.Get(context.TODO(), request.NamespacedName, rs)
 	if errors.IsNotFound(err) {
 		log.Printf("Could not find ReplicaSet %v.\n", request)
-		return reconcile.ReconcileResult{}, nil
+		return reconcile.Result{}, nil
 	}
 
 	if err != nil {
 		log.Printf("Could not fetch ReplicaSet %v for %+v\n", err, request)
-		return reconcile.ReconcileResult{}, err
+		return reconcile.Result{}, err
 	}
 
 	// Print the ReplicaSet
@@ -104,16 +104,16 @@ func (r *reconcileReplicaSet) Reconcile(request reconcile.ReconcileRequest) (rec
 		rs.Labels = map[string]string{}
 	}
 	if rs.Labels["hello"] == "world" {
-		return reconcile.ReconcileResult{}, nil
+		return reconcile.Result{}, nil
 	}
 
 	// Update the ReplicaSet
 	rs.Labels["hello"] = "world"
 	err = r.client.Update(context.TODO(), rs)
 	if err != nil {
 		log.Printf("Could not write ReplicaSet %v\n", err)
-		return reconcile.ReconcileResult{}, err
+		return reconcile.Result{}, err
 	}
 
-	return reconcile.ReconcileResult{}, nil
+	return reconcile.Result{}, nil
 }

pkg/controller/controller.go

@@ -39,8 +39,8 @@ import (
 
 var log = logf.KBLog.WithName("controller").WithName("controller")
 
-// ControllerArgs are the arguments for creating a new Controller
-type ControllerArgs struct {
+// Args are the arguments for creating a new Controller
+type Args struct {
 	// Name is used to uniquely identify a controller in tracing, logging and monitoring.  Name is required.
 	Name string
 
@@ -174,7 +174,7 @@ func (c *controller) processNextWorkItem() bool {
 
 	obj, shutdown := c.queue.Get()
 	if obj == nil {
-		log.Error(nil, "Encountered nil ReconcileRequest", "Object", obj)
+		log.Error(nil, "Encountered nil Request", "Object", obj)
 		c.queue.Forget(obj)
 	}
 
@@ -190,14 +190,14 @@ func (c *controller) processNextWorkItem() bool {
 	// put back on the workqueue and attempted again after a back-off
 	// period.
 	defer c.queue.Done(obj)
-	var req reconcile.ReconcileRequest
+	var req reconcile.Request
 	var ok bool
-	if req, ok = obj.(reconcile.ReconcileRequest); !ok {
+	if req, ok = obj.(reconcile.Request); !ok {
 		// As the item in the workqueue is actually invalid, we call
 		// Forget here else we'd go into a loop of attempting to
 		// process a work item that is invalid.
 		c.queue.Forget(obj)
-		log.Error(nil, "Queue item was not a ReconcileRequest",
+		log.Error(nil, "Queue item was not a Request",
 			"controller", c.name, "Type", fmt.Sprintf("%T", obj), "Value", obj)
 		// Return true, don't take a break
 		return true
@@ -207,7 +207,7 @@ func (c *controller) processNextWorkItem() bool {
 	// resource to be synced.
 	if result, err := c.reconcile.Reconcile(req); err != nil {
 		c.queue.AddRateLimited(req)
-		log.Error(nil, "reconcile error", "controller", c.name, "ReconcileRequest", req)
+		log.Error(nil, "reconcile error", "controller", c.name, "Request", req)
 
 		// TODO(pwittrock): FTO Returning an error here seems to back things off for a second before restarting
 		// the loop through wait.Util.
@@ -224,7 +224,7 @@ func (c *controller) processNextWorkItem() bool {
 	c.queue.Forget(obj)
 
 	// TODO(directxman12): What does 1 mean?  Do we want level constants?  Do we want levels at all?
-	log.V(1).Info("Successfully Reconciled", "controller", c.name, "ReconcileRequest", req)
+	log.V(1).Info("Successfully Reconciled", "controller", c.name, "Request", req)
 
 	// Return true, don't take a break
 	return true

pkg/controller/controller_integration_test.go

@@ -32,12 +32,12 @@ import (
 )
 
 var _ = Describe("controller", func() {
-	var reconciled chan reconcile.ReconcileRequest
+	var reconciled chan reconcile.Request
 	var stop chan struct{}
 
 	BeforeEach(func() {
 		stop = make(chan struct{})
-		reconciled = make(chan reconcile.ReconcileRequest)
+		reconciled = make(chan reconcile.Request)
 		Expect(cfg).NotTo(BeNil())
 	})
 
@@ -49,15 +49,15 @@ var _ = Describe("controller", func() {
 		// TODO(directxman12): write a whole suite of controller-client interaction tests
 
 		It("should reconcile", func(done Done) {
-			By("Creating the ControllerManager")
-			cm, err := controller.NewControllerManager(controller.ControllerManagerArgs{Config: cfg})
+			By("Creating the Manager")
+			cm, err := controller.NewManager(controller.ManagerArgs{Config: cfg})
 			Expect(err).NotTo(HaveOccurred())
 
 			By("Creating the Controller")
-			instance, err := cm.NewController(controller.ControllerArgs{Name: "foo-controller"}, reconcile.ReconcileFunc(
-				func(request reconcile.ReconcileRequest) (reconcile.ReconcileResult, error) {
+			instance, err := cm.NewController(controller.Args{Name: "foo-controller"}, reconcile.Func(
+				func(request reconcile.Request) (reconcile.Result, error) {
 					reconciled <- request
-					return reconcile.ReconcileResult{}, nil
+					return reconcile.Result{}, nil
 				}))
 			Expect(err).NotTo(HaveOccurred())
 
@@ -70,7 +70,7 @@ var _ = Describe("controller", func() {
 			err = instance.Watch(&source.KindSource{Type: &appsv1.Deployment{}}, &eventhandler.EnqueueHandler{})
 			Expect(err).NotTo(HaveOccurred())
 
-			By("Starting the ControllerManager")
+			By("Starting the Manager")
 			go func() {
 				defer GinkgoRecover()
 				Expect(cm.Start(stop)).NotTo(HaveOccurred())
@@ -95,7 +95,7 @@ var _ = Describe("controller", func() {
 					},
 				},
 			}
-			expectedReconcileRequest := reconcile.ReconcileRequest{NamespacedName: types.NamespacedName{
+			expectedReconcileRequest := reconcile.Request{NamespacedName: types.NamespacedName{
 				Namespace: "default",
 				Name:      "deployment-name",
 			}}

pkg/controller/controller_manager.go

@@ -33,13 +33,13 @@ import (
 	"k8s.io/client-go/util/workqueue"
 )
 
-// ControllerManager initializes shared dependencies such as Caches and Clients, and starts Controllers.
+// Manager initializes shared dependencies such as Caches and Clients, and starts Controllers.
 //
-// Dependencies may be retrieved from the ControllerManager using the Get* functions
-type ControllerManager interface {
+// Dependencies may be retrieved from the Manager using the Get* functions
+type Manager interface {
 	// NewController creates a new initialized Controller with the Reconcile function
-	// and registers it with the ControllerManager.
-	NewController(ControllerArgs, reconcile.Reconcile) (Controller, error)
+	// and registers it with the Manager.
+	NewController(Args, reconcile.Reconcile) (Controller, error)
 
 	// Start starts all registered Controllers and blocks until the Stop channel is closed.
 	// Returns an error if there is an error starting any controller.
@@ -58,7 +58,7 @@ type ControllerManager interface {
 	GetFieldIndexer() client.FieldIndexer
 }
 
-var _ ControllerManager = &controllerManager{}
+var _ Manager = &controllerManager{}
 
 type controllerManager struct {
 	// config is the rest.config used to talk to the apiserver.  Required.
@@ -88,12 +88,12 @@ type controllerManager struct {
 	stop    <-chan struct{}
 }
 
-func (cm *controllerManager) NewController(ca ControllerArgs, r reconcile.Reconcile) (Controller, error) {
+func (cm *controllerManager) NewController(ca Args, r reconcile.Reconcile) (Controller, error) {
 	cm.mu.Lock()
 	defer cm.mu.Unlock()
 
 	if len(ca.Name) == 0 {
-		return nil, fmt.Errorf("Must specify name for Controller.")
+		return nil, fmt.Errorf("must specify name for Controller")
 	}
 
 	if ca.MaxConcurrentReconciles <= 0 {
@@ -127,16 +127,16 @@ func (cm *controllerManager) NewController(ca ControllerArgs, r reconcile.Reconc
 }
 
 func (cm *controllerManager) injectInto(i interface{}) error {
-	if _, err := inject.InjectConfig(cm.config, i); err != nil {
+	if _, err := inject.DoConfig(cm.config, i); err != nil {
 		return err
 	}
-	if _, err := inject.InjectClient(cm.client, i); err != nil {
+	if _, err := inject.DoClient(cm.client, i); err != nil {
 		return err
 	}
-	if _, err := inject.InjectScheme(cm.scheme, i); err != nil {
+	if _, err := inject.DoScheme(cm.scheme, i); err != nil {
 		return err
 	}
-	if _, err := inject.InjectInformers(cm.informers, i); err != nil {
+	if _, err := inject.DoInformers(cm.informers, i); err != nil {
 		return err
 	}
 	return nil
@@ -187,8 +187,8 @@ func (cm *controllerManager) Start(stop <-chan struct{}) error {
 	}
 }
 
-// ControllerManagerArgs are the arguments for creating a new ControllerManager
-type ControllerManagerArgs struct {
+// ManagerArgs are the arguments for creating a new Manager
+type ManagerArgs struct {
 	// Config is the config used to talk to an apiserver.  Defaults to:
 	// 1. Config specified with the --config flag
 	// 2. Config specified with the KUBECONFIG environment variable
@@ -201,8 +201,8 @@ type ControllerManagerArgs struct {
 	Scheme *runtime.Scheme
 }
 
-// NewControllerManager returns a new fully initialized ControllerManager.
-func NewControllerManager(args ControllerManagerArgs) (ControllerManager, error) {
+// NewManager returns a new fully initialized Manager.
+func NewManager(args ManagerArgs) (Manager, error) {
 	cm := &controllerManager{config: args.Config, scheme: args.Scheme, errChan: make(chan error)}
 
 	// Initialize a rest.config if none was specified

pkg/controller/controller_suite_test.go

@@ -34,15 +34,15 @@ func TestSource(t *testing.T) {
 	RunSpecsWithDefaultAndCustomReporters(t, "controller Suite", []Reporter{test.NewlineReporter{}})
 }
 
-var testenv *test.TestEnvironment
+var testenv *test.Environment
 var cfg *rest.Config
 var clientset *kubernetes.Clientset
 var icache informer.Informers
 
 var _ = BeforeSuite(func() {
 	logf.SetLogger(logf.ZapLogger(true))
 
-	testenv = &test.TestEnvironment{}
+	testenv = &test.Environment{}
 
 	var err error
 	cfg, err = testenv.Start()

pkg/controller/doc.go

@@ -124,15 +124,15 @@ to Pod or ReplicaSet events.  The Reconcile function simply adds a label to the
 		flag.Parse()
 		logf.SetLogger(logf.ZapLogger(false))
 
-		// Setup a ControllerManager
-		manager, err := controller.NewControllerManager(controller.ControllerManagerArgs{})
+		// Setup a Manager
+		manager, err := controller.NewManager(controller.ManagerArgs{})
 		if err != nil {
 			log.Fatal(err)
 		}
 
 		// Setup a new controller to Reconcile ReplicaSets
 		c := manager.NewController(
-			controller.ControllerArgs{Name: "my-replicaset-controller", MaxConcurrentReconciles: 1},
+			controller.Args{Name: "my-replicaset-controller", MaxConcurrentReconciles: 1},
 			&ReconcileReplicaSet{client: manager.GetClient()},
 		)
 

pkg/controller/eventhandler/enqueue.go

@@ -28,7 +28,7 @@ var enqueueLog = logf.KBLog.WithName("eventhandler").WithName("EnqueueHandler")
 
 var _ EventHandler = &EnqueueHandler{}
 
-// EnqueueHandler enqueues a ReconcileRequest containing the Name and Namespace of the object for each event.
+// EnqueueHandler enqueues a Request containing the Name and Namespace of the object for each event.
 type EnqueueHandler struct{}
 
 // Create implements EventHandler
@@ -37,7 +37,7 @@ func (e *EnqueueHandler) Create(q workqueue.RateLimitingInterface, evt event.Cre
 		enqueueLog.Error(nil, "CreateEvent received with no metadata", "CreateEvent", evt)
 		return
 	}
-	q.AddRateLimited(reconcile.ReconcileRequest{NamespacedName: types.NamespacedName{
+	q.AddRateLimited(reconcile.Request{NamespacedName: types.NamespacedName{
 		Name:      evt.Meta.GetName(),
 		Namespace: evt.Meta.GetNamespace(),
 	}})
@@ -46,7 +46,7 @@ func (e *EnqueueHandler) Create(q workqueue.RateLimitingInterface, evt event.Cre
 // Update implements EventHandler
 func (e *EnqueueHandler) Update(q workqueue.RateLimitingInterface, evt event.UpdateEvent) {
 	if evt.MetaOld != nil {
-		q.AddRateLimited(reconcile.ReconcileRequest{NamespacedName: types.NamespacedName{
+		q.AddRateLimited(reconcile.Request{NamespacedName: types.NamespacedName{
 			Name:      evt.MetaOld.GetName(),
 			Namespace: evt.MetaOld.GetNamespace(),
 		}})
@@ -55,7 +55,7 @@ func (e *EnqueueHandler) Update(q workqueue.RateLimitingInterface, evt event.Upd
 	}
 
 	if evt.MetaNew != nil {
-		q.AddRateLimited(reconcile.ReconcileRequest{NamespacedName: types.NamespacedName{
+		q.AddRateLimited(reconcile.Request{NamespacedName: types.NamespacedName{
 			Name:      evt.MetaNew.GetName(),
 			Namespace: evt.MetaNew.GetNamespace(),
 		}})
@@ -70,7 +70,7 @@ func (e *EnqueueHandler) Delete(q workqueue.RateLimitingInterface, evt event.Del
 		enqueueLog.Error(nil, "DeleteEvent received with no metadata", "DeleteEvent", evt)
 		return
 	}
-	q.AddRateLimited(reconcile.ReconcileRequest{NamespacedName: types.NamespacedName{
+	q.AddRateLimited(reconcile.Request{NamespacedName: types.NamespacedName{
 		Name:      evt.Meta.GetName(),
 		Namespace: evt.Meta.GetNamespace(),
 	}})
@@ -82,7 +82,7 @@ func (e *EnqueueHandler) Generic(q workqueue.RateLimitingInterface, evt event.Ge
 		enqueueLog.Error(nil, "GenericEvent received with no metadata", "GenericEvent", evt)
 		return
 	}
-	q.AddRateLimited(reconcile.ReconcileRequest{NamespacedName: types.NamespacedName{
+	q.AddRateLimited(reconcile.Request{NamespacedName: types.NamespacedName{
 		Name:      evt.Meta.GetName(),
 		Namespace: evt.Meta.GetNamespace(),
 	}})

pkg/controller/eventhandler/enqueue_mapped.go

@@ -65,10 +65,10 @@ func (e *EnqueueMappedHandler) mapAndEnqueue(q workqueue.RateLimitingInterface,
 // Mapper maps an object to a collection of keys to be enqueued
 type Mapper interface {
 	// Map maps an object
-	Map(MapObject) []reconcile.ReconcileRequest
+	Map(MapObject) []reconcile.Request
 }
 
-// MapObject contains information from an event to be transformed into a ReconcileRequest.
+// MapObject contains information from an event to be transformed into a Request.
 type MapObject struct {
 	// Meta is the meta data for an object from an event.
 	Meta metav1.Object
@@ -80,9 +80,9 @@ type MapObject struct {
 var _ Mapper = ToRequestsFunc(nil)
 
 // ToRequestsFunc implements Mapper using a function.
-type ToRequestsFunc func(MapObject) []reconcile.ReconcileRequest
+type ToRequestsFunc func(MapObject) []reconcile.Request
 
 // Map implements Mapper
-func (m ToRequestsFunc) Map(i MapObject) []reconcile.ReconcileRequest {
+func (m ToRequestsFunc) Map(i MapObject) []reconcile.Request {
 	return m(i)
 }