Get rid of unecessary SchedulerLoopConfig detour to create a SchedulerLoop

contrib/mesos/pkg/scheduler/integration_test.go

@@ -482,17 +482,10 @@ func newLifecycleTest(t *testing.T) lifecycleTest {
 	// create scheduler process
 	schedulerProc := ha.New(mesosScheduler)
 
-	// get SchedulerLoop config from it
+	// create scheduler loop
 	fw := &MesosFramework{MesosScheduler: mesosScheduler}
-	config := operations.NewSchedulerLoopConfig(&c, fw, client, schedulerProc.Terminal(), http.DefaultServeMux, &podsListWatch.ListWatch)
-	assert.NotNil(config)
-
-	// make events observable
 	eventObs := NewEventObserver()
-	config.Recorder = eventObs
+	loop := operations.NewSchedulerLoop(&c, fw, client, eventObs, schedulerProc.Terminal(), http.DefaultServeMux, &podsListWatch.ListWatch)
-
-	// create loop
-	loop := operations.NewSchedulerLoop(config)
 	assert.NotNil(loop)
 
 	// create mock mesos scheduler driver

contrib/mesos/pkg/scheduler/operations/schedulerloop.go

@@ -17,6 +17,7 @@ limitations under the License.
 package operations
 
 import (
+	"net/http"
 	"time"
 
 	log "github.com/golang/glog"
@@ -31,8 +32,6 @@ import (
 	"k8s.io/kubernetes/pkg/client/cache"
 	"k8s.io/kubernetes/pkg/client/record"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
-	"k8s.io/kubernetes/pkg/fields"
-	"net/http"
 )
 
 const (
@@ -49,26 +48,19 @@ type SchedulerLoopInterface interface {
 	Run(<-chan struct{})
 }
 
-type SchedulerLoopConfig struct {
+type SchedulerLoop struct {
-	Algorithm *SchedulerAlgorithm
+	algorithm *SchedulerAlgorithm
-	Binder    *Binder
+	binder    *Binder
-	NextPod   func() *api.Pod
+	nextPod   func() *api.Pod
-	Error     func(*api.Pod, error)
+	error     func(*api.Pod, error)
-	Recorder  record.EventRecorder
+	recorder  record.EventRecorder
-	Client    *client.Client
+	client    *client.Client
-	Pr        *PodReconciler
+	pr        *PodReconciler
-	Starting  chan struct{} // startup latch
+	starting  chan struct{} // startup latch
 }
 
-// NewDefaultSchedulerLoopConfig creates a SchedulerLoop
+func NewSchedulerLoop(c *config.Config, fw types.Framework, client *client.Client, recorder record.EventRecorder,
-func NewDefaultSchedulerLoopConfig(c *config.Config, fw types.Framework, client *client.Client, terminate <-chan struct{}, mux *http.ServeMux) *SchedulerLoopConfig {
+	terminate <-chan struct{}, mux *http.ServeMux, podsWatcher *cache.ListWatch) *SchedulerLoop {
-	// use ListWatch watching pods using the client by default
-	lw := cache.NewListWatchFromClient(client, "pods", api.NamespaceAll, fields.Everything())
-	return NewSchedulerLoopConfig(c, fw, client, terminate, mux, lw)
-}
-
-func NewSchedulerLoopConfig(c *config.Config, fw types.Framework, client *client.Client, terminate <-chan struct{}, mux *http.ServeMux,
-	podsWatcher *cache.ListWatch) *SchedulerLoopConfig {
 
 	// Watch and queue pods that need scheduling.
 	updates := make(chan queue.Entry, c.UpdatesBacklog)
@@ -95,42 +87,18 @@ func NewSchedulerLoopConfig(c *config.Config, fw types.Framework, client *client
 		q.InstallDebugHandlers(mux)
 		podtask.InstallDebugHandlers(fw.Tasks(), mux)
 	})
-	return &SchedulerLoopConfig{
-		Algorithm: NewSchedulerAlgorithm(fw, podUpdates),
-		Binder:    NewBinder(fw),
-		NextPod:   q.Yield,
-		Error:     eh.Error,
-		Recorder:  eventBroadcaster.NewRecorder(api.EventSource{Component: "scheduler"}),
-		Client:    client,
-		Pr:        podReconciler,
-		Starting:  startLatch,
-	}
-}
-
-func NewSchedulerLoop(c *SchedulerLoopConfig) SchedulerLoopInterface {
 	return &SchedulerLoop{
-		algorithm: c.Algorithm,
+		algorithm: NewSchedulerAlgorithm(fw, podUpdates),
-		binder:    c.Binder,
+		binder:    NewBinder(fw),
-		nextPod:   c.NextPod,
+		nextPod:   q.Yield,
-		error:     c.Error,
+		error:     eh.Error,
-		recorder:  c.Recorder,
+		recorder:  recorder,
-		client:    c.Client,
+		client:    client,
-		pr:        c.Pr,
+		pr:        podReconciler,
-		starting:  c.Starting,
+		starting:  startLatch,
 	}
 }
 
-type SchedulerLoop struct {
-	algorithm *SchedulerAlgorithm
-	binder    *Binder
-	nextPod   func() *api.Pod
-	error     func(*api.Pod, error)
-	recorder  record.EventRecorder
-	client    *client.Client
-	pr        *PodReconciler
-	starting  chan struct{}
-}
-
 func (s *SchedulerLoop) Run(done <-chan struct{}) {
 	defer close(s.starting)
 	go runtime.Until(s.scheduleOne, recoveryDelay, done)

contrib/mesos/pkg/scheduler/operations/schedulerloop_test.go

@@ -1,32 +0,0 @@
-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package operations
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// Test to create the scheduler loop with an empty lopp config
-func TestPlugin_New(t *testing.T) {
-	assert := assert.New(t)
-
-	c := SchedulerLoopConfig{}
-	p := NewSchedulerLoop(&c)
-	assert.NotNil(p)
-}

contrib/mesos/pkg/scheduler/service/service.go

@@ -67,6 +67,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/client/cache"
+	"k8s.io/kubernetes/pkg/client/record"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	clientauth "k8s.io/kubernetes/pkg/client/unversioned/auth"
 	"k8s.io/kubernetes/pkg/fields"
@@ -759,8 +760,13 @@ func (s *SchedulerServer) bootstrap(hks hyperkube.Interface, sc *schedcfg.Config
 		},
 	}
 
+	// create scheduler loop
 	fw := &scheduler.MesosFramework{MesosScheduler: mesosScheduler}
-	loop := operations.NewSchedulerLoop(operations.NewDefaultSchedulerLoopConfig(sc, fw, client, schedulerProcess.Terminal(), s.mux))
+	eventBroadcaster := record.NewBroadcaster()
+	recorder := eventBroadcaster.NewRecorder(api.EventSource{Component: "scheduler"})
+	lw := cache.NewListWatchFromClient(client, "pods", api.NamespaceAll, fields.Everything())
+	loop := operations.NewSchedulerLoop(sc, fw, client, recorder, schedulerProcess.Terminal(), s.mux, lw)
+
 	runtime.On(mesosScheduler.Registration(), func() { loop.Run(schedulerProcess.Terminal()) })
 	runtime.On(mesosScheduler.Registration(), s.newServiceWriter(schedulerProcess.Terminal()))