Merge pull request #83573 from ahmad-diaa/remove-factory-package

Move Factory Package to Scheduler

cmd/kube-scheduler/app/options/BUILD

@@ -14,11 +14,11 @@ go_library(
         "//cmd/kube-scheduler/app/config:go_default_library",
         "//pkg/client/leaderelectionconfig:go_default_library",
         "//pkg/master/ports:go_default_library",
+        "//pkg/scheduler:go_default_library",
         "//pkg/scheduler/apis/config:go_default_library",
         "//pkg/scheduler/apis/config/scheme:go_default_library",
         "//pkg/scheduler/apis/config/v1alpha1:go_default_library",
         "//pkg/scheduler/apis/config/validation:go_default_library",
-        "//pkg/scheduler/factory:go_default_library",
         "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",

cmd/kube-scheduler/app/options/deprecated.go

@@ -22,8 +22,8 @@ import (
 	"github.com/spf13/pflag"
 
 	"k8s.io/apimachinery/pkg/util/validation/field"
+	"k8s.io/kubernetes/pkg/scheduler"
 	kubeschedulerconfig "k8s.io/kubernetes/pkg/scheduler/apis/config"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
 )
 
 // DeprecatedOptions contains deprecated options and their flags.
@@ -44,7 +44,7 @@ func (o *DeprecatedOptions) AddFlags(fs *pflag.FlagSet, cfg *kubeschedulerconfig
 		return
 	}
 
-	fs.StringVar(&o.AlgorithmProvider, "algorithm-provider", o.AlgorithmProvider, "DEPRECATED: the scheduling algorithm provider to use, one of: "+factory.ListAlgorithmProviders())
+	fs.StringVar(&o.AlgorithmProvider, "algorithm-provider", o.AlgorithmProvider, "DEPRECATED: the scheduling algorithm provider to use, one of: "+scheduler.ListAlgorithmProviders())
 	fs.StringVar(&o.PolicyConfigFile, "policy-config-file", o.PolicyConfigFile, "DEPRECATED: file with scheduler policy configuration. This file is used if policy ConfigMap is not provided or --use-legacy-policy-config=true")
 	usage := fmt.Sprintf("DEPRECATED: name of the ConfigMap object that contains scheduler's policy configuration. It must exist in the system namespace before scheduler initialization if --use-legacy-policy-config=false. The config must be provided as the value of an element in 'Data' map with the key='%v'", kubeschedulerconfig.SchedulerPolicyConfigMapKey)
 	fs.StringVar(&o.PolicyConfigMapName, "policy-configmap", o.PolicyConfigMapName, usage)

cmd/kube-scheduler/app/options/options.go

@@ -45,10 +45,10 @@ import (
 	schedulerappconfig "k8s.io/kubernetes/cmd/kube-scheduler/app/config"
 	"k8s.io/kubernetes/pkg/client/leaderelectionconfig"
 	"k8s.io/kubernetes/pkg/master/ports"
+	"k8s.io/kubernetes/pkg/scheduler"
 	kubeschedulerconfig "k8s.io/kubernetes/pkg/scheduler/apis/config"
 	kubeschedulerscheme "k8s.io/kubernetes/pkg/scheduler/apis/config/scheme"
 	"k8s.io/kubernetes/pkg/scheduler/apis/config/validation"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
 )
 
 // Options has all the params needed to run a Scheduler
@@ -253,7 +253,7 @@ func (o *Options) Config() (*schedulerappconfig.Config, error) {
 
 	c.Client = client
 	c.InformerFactory = informers.NewSharedInformerFactory(client, 0)
-	c.PodInformer = factory.NewPodInformer(client, 0)
+	c.PodInformer = scheduler.NewPodInformer(client, 0)
 	c.EventClient = eventClient.EventsV1beta1()
 	c.CoreEventClient = eventClient.CoreV1()
 	c.Recorder = recorder

pkg/scheduler/BUILD

@@ -3,7 +3,9 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "algorithm_factory.go",
         "eventhandlers.go",
+        "factory.go",
         "scheduler.go",
     ],
     importpath = "k8s.io/kubernetes/pkg/scheduler",
@@ -11,28 +13,45 @@ go_library(
     deps = [
         "//pkg/api/v1/pod:go_default_library",
         "//pkg/features:go_default_library",
+        "//pkg/scheduler/algorithm:go_default_library",
+        "//pkg/scheduler/algorithm/predicates:go_default_library",
+        "//pkg/scheduler/algorithm/priorities:go_default_library",
         "//pkg/scheduler/api:go_default_library",
         "//pkg/scheduler/api/latest:go_default_library",
+        "//pkg/scheduler/api/validation:go_default_library",
         "//pkg/scheduler/apis/config:go_default_library",
         "//pkg/scheduler/core:go_default_library",
-        "//pkg/scheduler/factory:go_default_library",
         "//pkg/scheduler/framework/plugins:go_default_library",
         "//pkg/scheduler/framework/v1alpha1:go_default_library",
         "//pkg/scheduler/internal/cache:go_default_library",
+        "//pkg/scheduler/internal/cache/debugger:go_default_library",
         "//pkg/scheduler/internal/queue:go_default_library",
         "//pkg/scheduler/metrics:go_default_library",
         "//pkg/scheduler/volumebinder:go_default_library",
         "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/api/storage/v1:go_default_library",
         "//staging/src/k8s.io/api/storage/v1beta1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/api/errors:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/fields:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/types:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
         "//staging/src/k8s.io/client-go/informers:go_default_library",
+        "//staging/src/k8s.io/client-go/informers/apps/v1:go_default_library",
         "//staging/src/k8s.io/client-go/informers/core/v1:go_default_library",
+        "//staging/src/k8s.io/client-go/informers/policy/v1beta1:go_default_library",
+        "//staging/src/k8s.io/client-go/informers/storage/v1:go_default_library",
+        "//staging/src/k8s.io/client-go/informers/storage/v1beta1:go_default_library",
         "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
+        "//staging/src/k8s.io/client-go/listers/apps/v1:go_default_library",
+        "//staging/src/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//staging/src/k8s.io/client-go/listers/policy/v1beta1:go_default_library",
+        "//staging/src/k8s.io/client-go/listers/storage/v1:go_default_library",
+        "//staging/src/k8s.io/client-go/listers/storage/v1beta1:go_default_library",
         "//staging/src/k8s.io/client-go/tools/cache:go_default_library",
         "//staging/src/k8s.io/client-go/tools/events:go_default_library",
         "//vendor/k8s.io/klog:go_default_library",
@@ -42,19 +61,24 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
+        "algorithm_factory_test.go",
         "eventhandlers_test.go",
+        "factory_test.go",
         "scheduler_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
+        "//pkg/api/testing:go_default_library",
         "//pkg/controller/volume/scheduling:go_default_library",
         "//pkg/scheduler/algorithm:go_default_library",
         "//pkg/scheduler/algorithm/predicates:go_default_library",
         "//pkg/scheduler/algorithm/priorities:go_default_library",
         "//pkg/scheduler/api:go_default_library",
+        "//pkg/scheduler/api/latest:go_default_library",
         "//pkg/scheduler/apis/config:go_default_library",
+        "//pkg/scheduler/apis/extender/v1:go_default_library",
         "//pkg/scheduler/core:go_default_library",
-        "//pkg/scheduler/factory:go_default_library",
+        "//pkg/scheduler/framework/plugins:go_default_library",
         "//pkg/scheduler/framework/v1alpha1:go_default_library",
         "//pkg/scheduler/internal/cache:go_default_library",
         "//pkg/scheduler/internal/cache/fake:go_default_library",
@@ -68,14 +92,20 @@ go_test(
         "//staging/src/k8s.io/apimachinery/pkg/labels:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/clock:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/diff:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
         "//staging/src/k8s.io/client-go/informers:go_default_library",
+        "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
         "//staging/src/k8s.io/client-go/kubernetes/fake:go_default_library",
         "//staging/src/k8s.io/client-go/kubernetes/scheme:go_default_library",
+        "//staging/src/k8s.io/client-go/kubernetes/typed/core/v1/fake:go_default_library",
+        "//staging/src/k8s.io/client-go/testing:go_default_library",
         "//staging/src/k8s.io/client-go/tools/cache:go_default_library",
         "//staging/src/k8s.io/client-go/tools/events:go_default_library",
+        "//vendor/github.com/google/go-cmp/cmp:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
     ],
 )
 
@@ -96,7 +126,6 @@ filegroup(
         "//pkg/scheduler/apis/config:all-srcs",
         "//pkg/scheduler/apis/extender/v1:all-srcs",
         "//pkg/scheduler/core:all-srcs",
-        "//pkg/scheduler/factory:all-srcs",
         "//pkg/scheduler/framework:all-srcs",
         "//pkg/scheduler/internal/cache:all-srcs",
         "//pkg/scheduler/internal/heap:all-srcs",

pkg/scheduler/algorithm_factory.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package factory
+package scheduler
 
 import (
 	"fmt"
@@ -111,8 +111,8 @@ type Snapshot struct {
 	algorithmProviderMap   map[string]AlgorithmProviderConfig
 }
 
-// Copy returns a snapshot of current registered predicates and priorities.
+// RegisteredPredicatesAndPrioritiesSnapshot returns a snapshot of current registered predicates and priorities.
-func Copy() *Snapshot {
+func RegisteredPredicatesAndPrioritiesSnapshot() *Snapshot {
 	schedulerFactoryMutex.RLock()
 	defer schedulerFactoryMutex.RUnlock()
 
@@ -147,8 +147,8 @@ func Copy() *Snapshot {
 	return &copy
 }
 
-// Apply sets state of predicates and priorities to `s`.
+// ApplyPredicatesAndPriorities sets state of predicates and priorities to `s`.
-func Apply(s *Snapshot) {
+func ApplyPredicatesAndPriorities(s *Snapshot) {
 	schedulerFactoryMutex.Lock()
 	fitPredicateMap = s.fitPredicateMap
 	mandatoryFitPredicates = s.mandatoryFitPredicates

pkg/scheduler/algorithm_factory_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package factory
+package scheduler
 
 import (
 	"testing"

pkg/scheduler/algorithmprovider/BUILD

@@ -19,7 +19,7 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//pkg/features:go_default_library",
-        "//pkg/scheduler/factory:go_default_library",
+        "//pkg/scheduler:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
         "//staging/src/k8s.io/component-base/featuregate/testing:go_default_library",
     ],

pkg/scheduler/algorithmprovider/defaults/BUILD

@@ -16,11 +16,11 @@ go_library(
     importpath = "k8s.io/kubernetes/pkg/scheduler/algorithmprovider/defaults",
     deps = [
         "//pkg/features:go_default_library",
+        "//pkg/scheduler:go_default_library",
         "//pkg/scheduler/algorithm:go_default_library",
         "//pkg/scheduler/algorithm/predicates:go_default_library",
         "//pkg/scheduler/algorithm/priorities:go_default_library",
         "//pkg/scheduler/core:go_default_library",
-        "//pkg/scheduler/factory:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
         "//vendor/k8s.io/klog:go_default_library",

pkg/scheduler/algorithmprovider/defaults/defaults.go

@@ -23,9 +23,9 @@ import (
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
 
 	"k8s.io/kubernetes/pkg/features"
+	"k8s.io/kubernetes/pkg/scheduler"
 	"k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
 	"k8s.io/kubernetes/pkg/scheduler/algorithm/priorities"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
 )
 
 const (
@@ -61,32 +61,32 @@ func defaultPredicates() sets.String {
 // when this function is called, and should be called in tests which may modify the value
 // of a feature gate temporarily.
 func ApplyFeatureGates() (restore func()) {
-	snapshot := factory.Copy()
+	snapshot := scheduler.RegisteredPredicatesAndPrioritiesSnapshot()
 	if utilfeature.DefaultFeatureGate.Enabled(features.TaintNodesByCondition) {
 		// Remove "CheckNodeCondition", "CheckNodeMemoryPressure", "CheckNodePIDPressure"
 		// and "CheckNodeDiskPressure" predicates
-		factory.RemoveFitPredicate(predicates.CheckNodeConditionPred)
+		scheduler.RemoveFitPredicate(predicates.CheckNodeConditionPred)
-		factory.RemoveFitPredicate(predicates.CheckNodeMemoryPressurePred)
+		scheduler.RemoveFitPredicate(predicates.CheckNodeMemoryPressurePred)
-		factory.RemoveFitPredicate(predicates.CheckNodeDiskPressurePred)
+		scheduler.RemoveFitPredicate(predicates.CheckNodeDiskPressurePred)
-		factory.RemoveFitPredicate(predicates.CheckNodePIDPressurePred)
+		scheduler.RemoveFitPredicate(predicates.CheckNodePIDPressurePred)
 		// Remove key "CheckNodeCondition", "CheckNodeMemoryPressure", "CheckNodePIDPressure" and "CheckNodeDiskPressure"
 		// from ALL algorithm provider
 		// The key will be removed from all providers which in algorithmProviderMap[]
 		// if you just want remove specific provider, call func RemovePredicateKeyFromAlgoProvider()
-		factory.RemovePredicateKeyFromAlgorithmProviderMap(predicates.CheckNodeConditionPred)
+		scheduler.RemovePredicateKeyFromAlgorithmProviderMap(predicates.CheckNodeConditionPred)
-		factory.RemovePredicateKeyFromAlgorithmProviderMap(predicates.CheckNodeMemoryPressurePred)
+		scheduler.RemovePredicateKeyFromAlgorithmProviderMap(predicates.CheckNodeMemoryPressurePred)
-		factory.RemovePredicateKeyFromAlgorithmProviderMap(predicates.CheckNodeDiskPressurePred)
+		scheduler.RemovePredicateKeyFromAlgorithmProviderMap(predicates.CheckNodeDiskPressurePred)
-		factory.RemovePredicateKeyFromAlgorithmProviderMap(predicates.CheckNodePIDPressurePred)
+		scheduler.RemovePredicateKeyFromAlgorithmProviderMap(predicates.CheckNodePIDPressurePred)
 
 		// Fit is determined based on whether a pod can tolerate all of the node's taints
-		factory.RegisterMandatoryFitPredicate(predicates.PodToleratesNodeTaintsPred, predicates.PodToleratesNodeTaints)
+		scheduler.RegisterMandatoryFitPredicate(predicates.PodToleratesNodeTaintsPred, predicates.PodToleratesNodeTaints)
 		// Fit is determined based on whether a pod can tolerate unschedulable of node
-		factory.RegisterMandatoryFitPredicate(predicates.CheckNodeUnschedulablePred, predicates.CheckNodeUnschedulablePredicate)
+		scheduler.RegisterMandatoryFitPredicate(predicates.CheckNodeUnschedulablePred, predicates.CheckNodeUnschedulablePredicate)
 		// Insert Key "PodToleratesNodeTaints" and "CheckNodeUnschedulable" To All Algorithm Provider
 		// The key will insert to all providers which in algorithmProviderMap[]
 		// if you just want insert to specific provider, call func InsertPredicateKeyToAlgoProvider()
-		factory.InsertPredicateKeyToAlgorithmProviderMap(predicates.PodToleratesNodeTaintsPred)
+		scheduler.InsertPredicateKeyToAlgorithmProviderMap(predicates.PodToleratesNodeTaintsPred)
-		factory.InsertPredicateKeyToAlgorithmProviderMap(predicates.CheckNodeUnschedulablePred)
+		scheduler.InsertPredicateKeyToAlgorithmProviderMap(predicates.CheckNodeUnschedulablePred)
 
 		klog.Infof("TaintNodesByCondition is enabled, PodToleratesNodeTaints predicate is mandatory")
 	}
@@ -95,23 +95,23 @@ func ApplyFeatureGates() (restore func()) {
 	if utilfeature.DefaultFeatureGate.Enabled(features.EvenPodsSpread) {
 		klog.Infof("Registering EvenPodsSpread predicate and priority function")
 		// register predicate
-		factory.InsertPredicateKeyToAlgorithmProviderMap(predicates.EvenPodsSpreadPred)
+		scheduler.InsertPredicateKeyToAlgorithmProviderMap(predicates.EvenPodsSpreadPred)
-		factory.RegisterFitPredicate(predicates.EvenPodsSpreadPred, predicates.EvenPodsSpreadPredicate)
+		scheduler.RegisterFitPredicate(predicates.EvenPodsSpreadPred, predicates.EvenPodsSpreadPredicate)
 		// register priority
-		factory.InsertPriorityKeyToAlgorithmProviderMap(priorities.EvenPodsSpreadPriority)
+		scheduler.InsertPriorityKeyToAlgorithmProviderMap(priorities.EvenPodsSpreadPriority)
-		factory.RegisterPriorityFunction(priorities.EvenPodsSpreadPriority, priorities.CalculateEvenPodsSpreadPriority, 1)
+		scheduler.RegisterPriorityFunction(priorities.EvenPodsSpreadPriority, priorities.CalculateEvenPodsSpreadPriority, 1)
 	}
 
 	// Prioritizes nodes that satisfy pod's resource limits
 	if utilfeature.DefaultFeatureGate.Enabled(features.ResourceLimitsPriorityFunction) {
 		klog.Infof("Registering resourcelimits priority function")
-		factory.RegisterPriorityMapReduceFunction(priorities.ResourceLimitsPriority, priorities.ResourceLimitsPriorityMap, nil, 1)
+		scheduler.RegisterPriorityMapReduceFunction(priorities.ResourceLimitsPriority, priorities.ResourceLimitsPriorityMap, nil, 1)
 		// Register the priority function to specific provider too.
-		factory.InsertPriorityKeyToAlgorithmProviderMap(factory.RegisterPriorityMapReduceFunction(priorities.ResourceLimitsPriority, priorities.ResourceLimitsPriorityMap, nil, 1))
+		scheduler.InsertPriorityKeyToAlgorithmProviderMap(scheduler.RegisterPriorityMapReduceFunction(priorities.ResourceLimitsPriority, priorities.ResourceLimitsPriorityMap, nil, 1))
 	}
 
 	restore = func() {
-		factory.Apply(snapshot)
+		scheduler.ApplyPredicatesAndPriorities(snapshot)
 	}
 	return
 }
@@ -119,9 +119,9 @@ func ApplyFeatureGates() (restore func()) {
 func registerAlgorithmProvider(predSet, priSet sets.String) {
 	// Registers algorithm providers. By default we use 'DefaultProvider', but user can specify one to be used
 	// by specifying flag.
-	factory.RegisterAlgorithmProvider(factory.DefaultProvider, predSet, priSet)
+	scheduler.RegisterAlgorithmProvider(scheduler.DefaultProvider, predSet, priSet)
 	// Cluster autoscaler friendly scheduling algorithm.
-	factory.RegisterAlgorithmProvider(ClusterAutoscalerProvider, predSet,
+	scheduler.RegisterAlgorithmProvider(ClusterAutoscalerProvider, predSet,
 		copyAndReplace(priSet, priorities.LeastRequestedPriority, priorities.MostRequestedPriority))
 }
 

pkg/scheduler/algorithmprovider/defaults/register_predicates.go

@@ -17,13 +17,13 @@ limitations under the License.
 package defaults
 
 import (
+	"k8s.io/kubernetes/pkg/scheduler"
 	"k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
 )
 
 func init() {
 	// Register functions that extract metadata used by predicates computations.
-	factory.RegisterPredicateMetadataProducer(predicates.GetPredicateMetadata)
+	scheduler.RegisterPredicateMetadataProducer(predicates.GetPredicateMetadata)
 
 	// IMPORTANT NOTES for predicate developers:
 	// Registers predicates and priorities that are not enabled by default, but user can pick when creating their
@@ -31,97 +31,97 @@ func init() {
 
 	// PodFitsPorts has been replaced by PodFitsHostPorts for better user understanding.
 	// For backwards compatibility with 1.0, PodFitsPorts is registered as well.
-	factory.RegisterFitPredicate("PodFitsPorts", predicates.PodFitsHostPorts)
+	scheduler.RegisterFitPredicate("PodFitsPorts", predicates.PodFitsHostPorts)
 	// Fit is defined based on the absence of port conflicts.
 	// This predicate is actually a default predicate, because it is invoked from
 	// predicates.GeneralPredicates()
-	factory.RegisterFitPredicate(predicates.PodFitsHostPortsPred, predicates.PodFitsHostPorts)
+	scheduler.RegisterFitPredicate(predicates.PodFitsHostPortsPred, predicates.PodFitsHostPorts)
 	// Fit is determined by resource availability.
 	// This predicate is actually a default predicate, because it is invoked from
 	// predicates.GeneralPredicates()
-	factory.RegisterFitPredicate(predicates.PodFitsResourcesPred, predicates.PodFitsResources)
+	scheduler.RegisterFitPredicate(predicates.PodFitsResourcesPred, predicates.PodFitsResources)
 	// Fit is determined by the presence of the Host parameter and a string match
 	// This predicate is actually a default predicate, because it is invoked from
 	// predicates.GeneralPredicates()
-	factory.RegisterFitPredicate(predicates.HostNamePred, predicates.PodFitsHost)
+	scheduler.RegisterFitPredicate(predicates.HostNamePred, predicates.PodFitsHost)
 	// Fit is determined by node selector query.
-	factory.RegisterFitPredicate(predicates.MatchNodeSelectorPred, predicates.PodMatchNodeSelector)
+	scheduler.RegisterFitPredicate(predicates.MatchNodeSelectorPred, predicates.PodMatchNodeSelector)
 
 	// Fit is determined by volume zone requirements.
-	factory.RegisterFitPredicateFactory(
+	scheduler.RegisterFitPredicateFactory(
 		predicates.NoVolumeZoneConflictPred,
-		func(args factory.PluginFactoryArgs) predicates.FitPredicate {
+		func(args scheduler.PluginFactoryArgs) predicates.FitPredicate {
 			return predicates.NewVolumeZonePredicate(args.PVInfo, args.PVCInfo, args.StorageClassInfo)
 		},
 	)
 	// Fit is determined by whether or not there would be too many AWS EBS volumes attached to the node
-	factory.RegisterFitPredicateFactory(
+	scheduler.RegisterFitPredicateFactory(
 		predicates.MaxEBSVolumeCountPred,
-		func(args factory.PluginFactoryArgs) predicates.FitPredicate {
+		func(args scheduler.PluginFactoryArgs) predicates.FitPredicate {
 			return predicates.NewMaxPDVolumeCountPredicate(predicates.EBSVolumeFilterType, args.CSINodeInfo, args.StorageClassInfo, args.PVInfo, args.PVCInfo)
 		},
 	)
 	// Fit is determined by whether or not there would be too many GCE PD volumes attached to the node
-	factory.RegisterFitPredicateFactory(
+	scheduler.RegisterFitPredicateFactory(
 		predicates.MaxGCEPDVolumeCountPred,
-		func(args factory.PluginFactoryArgs) predicates.FitPredicate {
+		func(args scheduler.PluginFactoryArgs) predicates.FitPredicate {
 			return predicates.NewMaxPDVolumeCountPredicate(predicates.GCEPDVolumeFilterType, args.CSINodeInfo, args.StorageClassInfo, args.PVInfo, args.PVCInfo)
 		},
 	)
 	// Fit is determined by whether or not there would be too many Azure Disk volumes attached to the node
-	factory.RegisterFitPredicateFactory(
+	scheduler.RegisterFitPredicateFactory(
 		predicates.MaxAzureDiskVolumeCountPred,
-		func(args factory.PluginFactoryArgs) predicates.FitPredicate {
+		func(args scheduler.PluginFactoryArgs) predicates.FitPredicate {
 			return predicates.NewMaxPDVolumeCountPredicate(predicates.AzureDiskVolumeFilterType, args.CSINodeInfo, args.StorageClassInfo, args.PVInfo, args.PVCInfo)
 		},
 	)
-	factory.RegisterFitPredicateFactory(
+	scheduler.RegisterFitPredicateFactory(
 		predicates.MaxCSIVolumeCountPred,
-		func(args factory.PluginFactoryArgs) predicates.FitPredicate {
+		func(args scheduler.PluginFactoryArgs) predicates.FitPredicate {
 			return predicates.NewCSIMaxVolumeLimitPredicate(args.CSINodeInfo, args.PVInfo, args.PVCInfo, args.StorageClassInfo)
 		},
 	)
-	factory.RegisterFitPredicateFactory(
+	scheduler.RegisterFitPredicateFactory(
 		predicates.MaxCinderVolumeCountPred,
-		func(args factory.PluginFactoryArgs) predicates.FitPredicate {
+		func(args scheduler.PluginFactoryArgs) predicates.FitPredicate {
 			return predicates.NewMaxPDVolumeCountPredicate(predicates.CinderVolumeFilterType, args.CSINodeInfo, args.StorageClassInfo, args.PVInfo, args.PVCInfo)
 		},
 	)
 
 	// Fit is determined by inter-pod affinity.
-	factory.RegisterFitPredicateFactory(
+	scheduler.RegisterFitPredicateFactory(
 		predicates.MatchInterPodAffinityPred,
-		func(args factory.PluginFactoryArgs) predicates.FitPredicate {
+		func(args scheduler.PluginFactoryArgs) predicates.FitPredicate {
 			return predicates.NewPodAffinityPredicate(args.NodeInfo, args.PodLister)
 		},
 	)
 
 	// Fit is determined by non-conflicting disk volumes.
-	factory.RegisterFitPredicate(predicates.NoDiskConflictPred, predicates.NoDiskConflict)
+	scheduler.RegisterFitPredicate(predicates.NoDiskConflictPred, predicates.NoDiskConflict)
 
 	// GeneralPredicates are the predicates that are enforced by all Kubernetes components
 	// (e.g. kubelet and all schedulers)
-	factory.RegisterFitPredicate(predicates.GeneralPred, predicates.GeneralPredicates)
+	scheduler.RegisterFitPredicate(predicates.GeneralPred, predicates.GeneralPredicates)
 
 	// Fit is determined by node memory pressure condition.
-	factory.RegisterFitPredicate(predicates.CheckNodeMemoryPressurePred, predicates.CheckNodeMemoryPressurePredicate)
+	scheduler.RegisterFitPredicate(predicates.CheckNodeMemoryPressurePred, predicates.CheckNodeMemoryPressurePredicate)
 
 	// Fit is determined by node disk pressure condition.
-	factory.RegisterFitPredicate(predicates.CheckNodeDiskPressurePred, predicates.CheckNodeDiskPressurePredicate)
+	scheduler.RegisterFitPredicate(predicates.CheckNodeDiskPressurePred, predicates.CheckNodeDiskPressurePredicate)
 
 	// Fit is determined by node pid pressure condition.
-	factory.RegisterFitPredicate(predicates.CheckNodePIDPressurePred, predicates.CheckNodePIDPressurePredicate)
+	scheduler.RegisterFitPredicate(predicates.CheckNodePIDPressurePred, predicates.CheckNodePIDPressurePredicate)
 
 	// Fit is determined by node conditions: not ready, network unavailable or out of disk.
-	factory.RegisterMandatoryFitPredicate(predicates.CheckNodeConditionPred, predicates.CheckNodeConditionPredicate)
+	scheduler.RegisterMandatoryFitPredicate(predicates.CheckNodeConditionPred, predicates.CheckNodeConditionPredicate)
 
 	// Fit is determined based on whether a pod can tolerate all of the node's taints
-	factory.RegisterFitPredicate(predicates.PodToleratesNodeTaintsPred, predicates.PodToleratesNodeTaints)
+	scheduler.RegisterFitPredicate(predicates.PodToleratesNodeTaintsPred, predicates.PodToleratesNodeTaints)
 
 	// Fit is determined by volume topology requirements.
-	factory.RegisterFitPredicateFactory(
+	scheduler.RegisterFitPredicateFactory(
 		predicates.CheckVolumeBindingPred,
-		func(args factory.PluginFactoryArgs) predicates.FitPredicate {
+		func(args scheduler.PluginFactoryArgs) predicates.FitPredicate {
 			return predicates.NewVolumeBindingPredicate(args.VolumeBinder)
 		},
 	)

pkg/scheduler/algorithmprovider/defaults/register_priorities.go

@@ -17,16 +17,16 @@ limitations under the License.
 package defaults
 
 import (
+	"k8s.io/kubernetes/pkg/scheduler"
 	"k8s.io/kubernetes/pkg/scheduler/algorithm"
 	"k8s.io/kubernetes/pkg/scheduler/algorithm/priorities"
 	"k8s.io/kubernetes/pkg/scheduler/core"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
 )
 
 func init() {
 	// Register functions that extract metadata used by priorities computations.
-	factory.RegisterPriorityMetadataProducerFactory(
+	scheduler.RegisterPriorityMetadataProducerFactory(
-		func(args factory.PluginFactoryArgs) priorities.PriorityMetadataProducer {
+		func(args scheduler.PluginFactoryArgs) priorities.PriorityMetadataProducer {
 			return priorities.NewPriorityMetadataFactory(args.ServiceLister, args.ControllerLister, args.ReplicaSetLister, args.StatefulSetLister)
 		})
 
@@ -34,10 +34,10 @@ func init() {
 	// the number of pods (belonging to the same service) on the same node.
 	// Register the factory so that it's available, but do not include it as part of the default priorities
 	// Largely replaced by "SelectorSpreadPriority", but registered for backward compatibility with 1.0
-	factory.RegisterPriorityConfigFactory(
+	scheduler.RegisterPriorityConfigFactory(
 		priorities.ServiceSpreadingPriority,
-		factory.PriorityConfigFactory{
+		scheduler.PriorityConfigFactory{
-			MapReduceFunction: func(args factory.PluginFactoryArgs) (priorities.PriorityMapFunction, priorities.PriorityReduceFunction) {
+			MapReduceFunction: func(args scheduler.PluginFactoryArgs) (priorities.PriorityMapFunction, priorities.PriorityReduceFunction) {
 				return priorities.NewSelectorSpreadPriority(args.ServiceLister, algorithm.EmptyControllerLister{}, algorithm.EmptyReplicaSetLister{}, algorithm.EmptyStatefulSetLister{})
 			},
 			Weight: 1,
@@ -46,19 +46,19 @@ func init() {
 	// EqualPriority is a prioritizer function that gives an equal weight of one to all nodes
 	// Register the priority function so that its available
 	// but do not include it as part of the default priorities
-	factory.RegisterPriorityMapReduceFunction(priorities.EqualPriority, core.EqualPriorityMap, nil, 1)
+	scheduler.RegisterPriorityMapReduceFunction(priorities.EqualPriority, core.EqualPriorityMap, nil, 1)
 	// Optional, cluster-autoscaler friendly priority function - give used nodes higher priority.
-	factory.RegisterPriorityMapReduceFunction(priorities.MostRequestedPriority, priorities.MostRequestedPriorityMap, nil, 1)
+	scheduler.RegisterPriorityMapReduceFunction(priorities.MostRequestedPriority, priorities.MostRequestedPriorityMap, nil, 1)
-	factory.RegisterPriorityMapReduceFunction(
+	scheduler.RegisterPriorityMapReduceFunction(
 		priorities.RequestedToCapacityRatioPriority,
 		priorities.RequestedToCapacityRatioResourceAllocationPriorityDefault().PriorityMap,
 		nil,
 		1)
 	// spreads pods by minimizing the number of pods (belonging to the same service or replication controller) on the same node.
-	factory.RegisterPriorityConfigFactory(
+	scheduler.RegisterPriorityConfigFactory(
 		priorities.SelectorSpreadPriority,
-		factory.PriorityConfigFactory{
+		scheduler.PriorityConfigFactory{
-			MapReduceFunction: func(args factory.PluginFactoryArgs) (priorities.PriorityMapFunction, priorities.PriorityReduceFunction) {
+			MapReduceFunction: func(args scheduler.PluginFactoryArgs) (priorities.PriorityMapFunction, priorities.PriorityReduceFunction) {
 				return priorities.NewSelectorSpreadPriority(args.ServiceLister, args.ControllerLister, args.ReplicaSetLister, args.StatefulSetLister)
 			},
 			Weight: 1,
@@ -66,10 +66,10 @@ func init() {
 	)
 	// pods should be placed in the same topological domain (e.g. same node, same rack, same zone, same power domain, etc.)
 	// as some other pods, or, conversely, should not be placed in the same topological domain as some other pods.
-	factory.RegisterPriorityConfigFactory(
+	scheduler.RegisterPriorityConfigFactory(
 		priorities.InterPodAffinityPriority,
-		factory.PriorityConfigFactory{
+		scheduler.PriorityConfigFactory{
-			Function: func(args factory.PluginFactoryArgs) priorities.PriorityFunction {
+			Function: func(args scheduler.PluginFactoryArgs) priorities.PriorityFunction {
 				return priorities.NewInterPodAffinityPriority(args.NodeInfo, args.HardPodAffinitySymmetricWeight)
 			},
 			Weight: 1,
@@ -77,21 +77,21 @@ func init() {
 	)
 
 	// Prioritize nodes by least requested utilization.
-	factory.RegisterPriorityMapReduceFunction(priorities.LeastRequestedPriority, priorities.LeastRequestedPriorityMap, nil, 1)
+	scheduler.RegisterPriorityMapReduceFunction(priorities.LeastRequestedPriority, priorities.LeastRequestedPriorityMap, nil, 1)
 
 	// Prioritizes nodes to help achieve balanced resource usage
-	factory.RegisterPriorityMapReduceFunction(priorities.BalancedResourceAllocation, priorities.BalancedResourceAllocationMap, nil, 1)
+	scheduler.RegisterPriorityMapReduceFunction(priorities.BalancedResourceAllocation, priorities.BalancedResourceAllocationMap, nil, 1)
 
 	// Set this weight large enough to override all other priority functions.
 	// TODO: Figure out a better way to do this, maybe at same time as fixing #24720.
-	factory.RegisterPriorityMapReduceFunction(priorities.NodePreferAvoidPodsPriority, priorities.CalculateNodePreferAvoidPodsPriorityMap, nil, 10000)
+	scheduler.RegisterPriorityMapReduceFunction(priorities.NodePreferAvoidPodsPriority, priorities.CalculateNodePreferAvoidPodsPriorityMap, nil, 10000)
 
 	// Prioritizes nodes that have labels matching NodeAffinity
-	factory.RegisterPriorityMapReduceFunction(priorities.NodeAffinityPriority, priorities.CalculateNodeAffinityPriorityMap, priorities.CalculateNodeAffinityPriorityReduce, 1)
+	scheduler.RegisterPriorityMapReduceFunction(priorities.NodeAffinityPriority, priorities.CalculateNodeAffinityPriorityMap, priorities.CalculateNodeAffinityPriorityReduce, 1)
 
 	// Prioritizes nodes that marked with taint which pod can tolerate.
-	factory.RegisterPriorityMapReduceFunction(priorities.TaintTolerationPriority, priorities.ComputeTaintTolerationPriorityMap, priorities.ComputeTaintTolerationPriorityReduce, 1)
+	scheduler.RegisterPriorityMapReduceFunction(priorities.TaintTolerationPriority, priorities.ComputeTaintTolerationPriorityMap, priorities.ComputeTaintTolerationPriorityReduce, 1)
 
 	// ImageLocalityPriority prioritizes nodes that have images requested by the pod present.
-	factory.RegisterPriorityMapReduceFunction(priorities.ImageLocalityPriority, priorities.ImageLocalityPriorityMap, nil, 1)
+	scheduler.RegisterPriorityMapReduceFunction(priorities.ImageLocalityPriority, priorities.ImageLocalityPriorityMap, nil, 1)
 }

pkg/scheduler/algorithmprovider/plugins_test.go

@@ -23,17 +23,17 @@ import (
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	featuregatetesting "k8s.io/component-base/featuregate/testing"
 	"k8s.io/kubernetes/pkg/features"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
+	"k8s.io/kubernetes/pkg/scheduler"
 )
 
 var (
 	algorithmProviderNames = []string{
-		factory.DefaultProvider,
+		scheduler.DefaultProvider,
 	}
 )
 
 func TestDefaultConfigExists(t *testing.T) {
-	p, err := factory.GetAlgorithmProvider(factory.DefaultProvider)
+	p, err := scheduler.GetAlgorithmProvider(scheduler.DefaultProvider)
 	if err != nil {
 		t.Errorf("error retrieving default provider: %v", err)
 	}
@@ -48,7 +48,7 @@ func TestDefaultConfigExists(t *testing.T) {
 func TestAlgorithmProviders(t *testing.T) {
 	for _, pn := range algorithmProviderNames {
 		t.Run(pn, func(t *testing.T) {
-			p, err := factory.GetAlgorithmProvider(pn)
+			p, err := scheduler.GetAlgorithmProvider(pn)
 			if err != nil {
 				t.Fatalf("error retrieving provider: %v", err)
 			}
@@ -57,14 +57,14 @@ func TestAlgorithmProviders(t *testing.T) {
 			}
 			for _, pf := range p.PriorityFunctionKeys.List() {
 				t.Run(fmt.Sprintf("priorityfunction/%s", pf), func(t *testing.T) {
-					if !factory.IsPriorityFunctionRegistered(pf) {
+					if !scheduler.IsPriorityFunctionRegistered(pf) {
 						t.Errorf("priority function is not registered but is used in the algorithm provider")
 					}
 				})
 			}
 			for _, fp := range p.FitPredicateKeys.List() {
 				t.Run(fmt.Sprintf("fitpredicate/%s", fp), func(t *testing.T) {
-					if !factory.IsFitPredicateRegistered(fp) {
+					if !scheduler.IsFitPredicateRegistered(fp) {
 						t.Errorf("fit predicate is not registered but is used in the algorithm provider")
 					}
 				})
@@ -76,7 +76,7 @@ func TestAlgorithmProviders(t *testing.T) {
 func TestApplyFeatureGates(t *testing.T) {
 	for _, pn := range algorithmProviderNames {
 		t.Run(pn, func(t *testing.T) {
-			p, err := factory.GetAlgorithmProvider(pn)
+			p, err := scheduler.GetAlgorithmProvider(pn)
 			if err != nil {
 				t.Fatalf("Error retrieving provider: %v", err)
 			}
@@ -98,7 +98,7 @@ func TestApplyFeatureGates(t *testing.T) {
 
 	for _, pn := range algorithmProviderNames {
 		t.Run(pn, func(t *testing.T) {
-			p, err := factory.GetAlgorithmProvider(pn)
+			p, err := scheduler.GetAlgorithmProvider(pn)
 			if err != nil {
 				t.Fatalf("Error retrieving '%s' provider: %v", pn, err)
 			}

pkg/scheduler/api/compatibility/BUILD

@@ -10,7 +10,6 @@ go_test(
         "//pkg/scheduler/api:go_default_library",
         "//pkg/scheduler/apis/config:go_default_library",
         "//pkg/scheduler/core:go_default_library",
-        "//pkg/scheduler/factory:go_default_library",
         "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",

pkg/scheduler/api/compatibility/compatibility_test.go

@@ -33,7 +33,6 @@ import (
 	kubeschedulerconfig "k8s.io/kubernetes/pkg/scheduler/apis/config"
 	schedulerconfig "k8s.io/kubernetes/pkg/scheduler/apis/config"
 	"k8s.io/kubernetes/pkg/scheduler/core"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
 )
 
 func TestCompatibility_v1_Scheduler(t *testing.T) {
@@ -1178,8 +1177,8 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
 			}},
 		},
 	}
-	registeredPredicates := sets.NewString(factory.ListRegisteredFitPredicates()...)
+	registeredPredicates := sets.NewString(scheduler.ListRegisteredFitPredicates()...)
-	registeredPriorities := sets.NewString(factory.ListRegisteredPriorityFunctions()...)
+	registeredPriorities := sets.NewString(scheduler.ListRegisteredPriorityFunctions()...)
 	seenPredicates := sets.NewString()
 	seenPriorities := sets.NewString()
 	mandatoryPredicates := sets.NewString("CheckNodeCondition")

pkg/scheduler/eventhandlers_test.go

@@ -23,7 +23,6 @@ import (
 	"k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
 
 	fakecache "k8s.io/kubernetes/pkg/scheduler/internal/cache/fake"
 )
@@ -106,7 +105,7 @@ func TestSkipPodUpdate(t *testing.T) {
 	}
 	for _, test := range table {
 		t.Run(test.name, func(t *testing.T) {
-			c := NewFromConfig(&factory.Config{
+			c := NewFromConfig(&Config{
 				SchedulerCache: &fakecache.Cache{
 					IsAssumedPodFunc: test.isAssumedPodFunc,
 					GetPodFunc:       test.getPodFunc,

pkg/scheduler/factory.go

@@ -14,9 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Package factory can set up a scheduler. This code is here instead of
+package scheduler
-// cmd/scheduler for both testability and reuse.
-package factory
 
 import (
 	"fmt"

pkg/scheduler/factory/BUILD

@@ -1,102 +0,0 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "factory.go",
-        "plugins.go",
-    ],
-    importpath = "k8s.io/kubernetes/pkg/scheduler/factory",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//pkg/features:go_default_library",
-        "//pkg/scheduler/algorithm:go_default_library",
-        "//pkg/scheduler/algorithm/predicates:go_default_library",
-        "//pkg/scheduler/algorithm/priorities:go_default_library",
-        "//pkg/scheduler/api:go_default_library",
-        "//pkg/scheduler/api/validation:go_default_library",
-        "//pkg/scheduler/apis/config:go_default_library",
-        "//pkg/scheduler/core:go_default_library",
-        "//pkg/scheduler/framework/plugins:go_default_library",
-        "//pkg/scheduler/framework/v1alpha1:go_default_library",
-        "//pkg/scheduler/internal/cache:go_default_library",
-        "//pkg/scheduler/internal/cache/debugger:go_default_library",
-        "//pkg/scheduler/internal/queue:go_default_library",
-        "//pkg/scheduler/volumebinder:go_default_library",
-        "//staging/src/k8s.io/api/core/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/api/errors:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/fields:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/types:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
-        "//staging/src/k8s.io/client-go/informers:go_default_library",
-        "//staging/src/k8s.io/client-go/informers/apps/v1:go_default_library",
-        "//staging/src/k8s.io/client-go/informers/core/v1:go_default_library",
-        "//staging/src/k8s.io/client-go/informers/policy/v1beta1:go_default_library",
-        "//staging/src/k8s.io/client-go/informers/storage/v1:go_default_library",
-        "//staging/src/k8s.io/client-go/informers/storage/v1beta1:go_default_library",
-        "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
-        "//staging/src/k8s.io/client-go/listers/apps/v1:go_default_library",
-        "//staging/src/k8s.io/client-go/listers/core/v1:go_default_library",
-        "//staging/src/k8s.io/client-go/listers/policy/v1beta1:go_default_library",
-        "//staging/src/k8s.io/client-go/listers/storage/v1:go_default_library",
-        "//staging/src/k8s.io/client-go/listers/storage/v1beta1:go_default_library",
-        "//staging/src/k8s.io/client-go/tools/cache:go_default_library",
-        "//staging/src/k8s.io/client-go/tools/events:go_default_library",
-        "//vendor/k8s.io/klog:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = [
-        "factory_test.go",
-        "plugins_test.go",
-    ],
-    embed = [":go_default_library"],
-    deps = [
-        "//pkg/api/testing:go_default_library",
-        "//pkg/scheduler/algorithm:go_default_library",
-        "//pkg/scheduler/algorithm/predicates:go_default_library",
-        "//pkg/scheduler/algorithm/priorities:go_default_library",
-        "//pkg/scheduler/api:go_default_library",
-        "//pkg/scheduler/api/latest:go_default_library",
-        "//pkg/scheduler/apis/config:go_default_library",
-        "//pkg/scheduler/apis/extender/v1:go_default_library",
-        "//pkg/scheduler/framework/plugins:go_default_library",
-        "//pkg/scheduler/framework/v1alpha1:go_default_library",
-        "//pkg/scheduler/internal/cache:go_default_library",
-        "//pkg/scheduler/internal/queue:go_default_library",
-        "//pkg/scheduler/nodeinfo:go_default_library",
-        "//staging/src/k8s.io/api/core/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/clock:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",
-        "//staging/src/k8s.io/client-go/informers:go_default_library",
-        "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
-        "//staging/src/k8s.io/client-go/kubernetes/fake:go_default_library",
-        "//staging/src/k8s.io/client-go/kubernetes/typed/core/v1/fake:go_default_library",
-        "//staging/src/k8s.io/client-go/testing:go_default_library",
-        "//staging/src/k8s.io/client-go/tools/cache:go_default_library",
-        "//vendor/github.com/google/go-cmp/cmp:go_default_library",
-        "//vendor/github.com/stretchr/testify/assert:go_default_library",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)

pkg/scheduler/factory_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package factory
+package scheduler
 
 import (
 	"errors"
@@ -583,7 +583,7 @@ func TestGetBinderFunc(t *testing.T) {
 			extenders: []algorithm.SchedulerExtender{
 				&fakeExtender{isBinder: false, interestedPodName: "pod0"},
 			},
-			expectedBinderType: "*factory.binder",
+			expectedBinderType: "*scheduler.binder",
 		},
 		{
 			name:    "one of the extenders is a binder and interested in pod",
@@ -592,7 +592,7 @@ func TestGetBinderFunc(t *testing.T) {
 				&fakeExtender{isBinder: false, interestedPodName: "pod0"},
 				&fakeExtender{isBinder: true, interestedPodName: "pod0"},
 			},
-			expectedBinderType: "*factory.fakeExtender",
+			expectedBinderType: "*scheduler.fakeExtender",
 		},
 		{
 			name:    "one of the extenders is a binder, but not interested in pod",
@@ -601,7 +601,7 @@ func TestGetBinderFunc(t *testing.T) {
 				&fakeExtender{isBinder: false, interestedPodName: "pod1"},
 				&fakeExtender{isBinder: true, interestedPodName: "pod0"},
 			},
-			expectedBinderType: "*factory.binder",
+			expectedBinderType: "*scheduler.binder",
 		},
 	}
 

pkg/scheduler/scheduler.go

@@ -37,7 +37,6 @@ import (
 	latestschedulerapi "k8s.io/kubernetes/pkg/scheduler/api/latest"
 	kubeschedulerconfig "k8s.io/kubernetes/pkg/scheduler/apis/config"
 	"k8s.io/kubernetes/pkg/scheduler/core"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
 	frameworkplugins "k8s.io/kubernetes/pkg/scheduler/framework/plugins"
 	framework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
 	internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache"
@@ -78,7 +77,7 @@ type Scheduler struct {
 	SchedulerCache internalcache.Cache
 
 	Algorithm core.ScheduleAlgorithm
-	GetBinder func(pod *v1.Pod) factory.Binder
+	GetBinder func(pod *v1.Pod) Binder
 	// PodConditionUpdater is used only in case of scheduling errors. If we succeed
 	// with scheduling, PodScheduled condition will be updated in apiserver in /bind
 	// handler so that binding and setting PodCondition it is atomic.
@@ -289,7 +288,7 @@ func New(client clientset.Interface,
 	registry.Merge(options.frameworkOutOfTreeRegistry)
 
 	// Set up the configurator which can create schedulers from configs.
-	configurator := factory.NewConfigFactory(&factory.ConfigFactoryArgs{
+	configurator := NewConfigFactory(&ConfigFactoryArgs{
 		Client:                         client,
 		InformerFactory:                informerFactory,
 		PodInformer:                    podInformer,
@@ -316,7 +315,7 @@ func New(client clientset.Interface,
 		Plugins:                        options.frameworkPlugins,
 		PluginConfig:                   options.frameworkPluginConfig,
 	})
-	var config *factory.Config
+	var config *Config
 	source := schedulerAlgorithmSource
 	switch {
 	case source.Provider != nil:
@@ -398,7 +397,7 @@ func initPolicyFromConfigMap(client clientset.Interface, policyRef *kubeschedule
 }
 
 // NewFromConfig returns a new scheduler using the provided Config.
-func NewFromConfig(config *factory.Config) *Scheduler {
+func NewFromConfig(config *Config) *Scheduler {
 	metrics.Register()
 	return &Scheduler{
 		SchedulerCache:    config.SchedulerCache,

pkg/scheduler/scheduler_test.go

@@ -48,7 +48,6 @@ import (
 	schedulerapi "k8s.io/kubernetes/pkg/scheduler/api"
 	kubeschedulerconfig "k8s.io/kubernetes/pkg/scheduler/apis/config"
 	"k8s.io/kubernetes/pkg/scheduler/core"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
 	framework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
 	internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache"
 	fakecache "k8s.io/kubernetes/pkg/scheduler/internal/cache/fake"
@@ -176,15 +175,15 @@ func TestSchedulerCreation(t *testing.T) {
 	testSource := "testProvider"
 	eventBroadcaster := events.NewBroadcaster(&events.EventSinkImpl{Interface: client.EventsV1beta1().Events("")})
 
-	factory.RegisterFitPredicate("PredicateOne", PredicateOne)
+	RegisterFitPredicate("PredicateOne", PredicateOne)
-	factory.RegisterPriorityFunction("PriorityOne", PriorityOne, 1)
+	RegisterPriorityFunction("PriorityOne", PriorityOne, 1)
-	factory.RegisterAlgorithmProvider(testSource, sets.NewString("PredicateOne"), sets.NewString("PriorityOne"))
+	RegisterAlgorithmProvider(testSource, sets.NewString("PredicateOne"), sets.NewString("PriorityOne"))
 
 	stopCh := make(chan struct{})
 	defer close(stopCh)
 	_, err := New(client,
 		informerFactory,
-		factory.NewPodInformer(client, 0),
+		NewPodInformer(client, 0),
 		eventBroadcaster.NewRecorder(scheme.Scheme, "scheduler"),
 		kubeschedulerconfig.SchedulerAlgorithmSource{Provider: &testSource},
 		stopCh,
@@ -276,7 +275,7 @@ func TestScheduler(t *testing.T) {
 			s := &Scheduler{
 				SchedulerCache: sCache,
 				Algorithm:      item.algo,
-				GetBinder: func(pod *v1.Pod) factory.Binder {
+				GetBinder: func(pod *v1.Pod) Binder {
 					return fakeBinder{func(b *v1.Binding) error {
 						gotBinding = b
 						return item.injectBindError
@@ -660,7 +659,7 @@ func setupTestScheduler(queuedPodStore *clientcache.FIFO, scache internalcache.C
 	sched := &Scheduler{
 		SchedulerCache: scache,
 		Algorithm:      algo,
-		GetBinder: func(pod *v1.Pod) factory.Binder {
+		GetBinder: func(pod *v1.Pod) Binder {
 			return fakeBinder{func(b *v1.Binding) error {
 				bindingChan <- b
 				return nil
@@ -710,7 +709,7 @@ func setupTestSchedulerLongBindingWithRetry(queuedPodStore *clientcache.FIFO, sc
 	sched := &Scheduler{
 		SchedulerCache: scache,
 		Algorithm:      algo,
-		GetBinder: func(pod *v1.Pod) factory.Binder {
+		GetBinder: func(pod *v1.Pod) Binder {
 			return fakeBinder{func(b *v1.Binding) error {
 				time.Sleep(bindingTime)
 				bindingChan <- b

test/integration/scheduler/BUILD

@@ -33,7 +33,6 @@ go_test(
         "//pkg/scheduler/api:go_default_library",
         "//pkg/scheduler/apis/config:go_default_library",
         "//pkg/scheduler/apis/extender/v1:go_default_library",
-        "//pkg/scheduler/factory:go_default_library",
         "//pkg/scheduler/framework/v1alpha1:go_default_library",
         "//pkg/scheduler/nodeinfo:go_default_library",
         "//pkg/scheduler/testing:go_default_library",
@@ -96,7 +95,6 @@ go_library(
         "//pkg/scheduler/api:go_default_library",
         "//pkg/scheduler/api/latest:go_default_library",
         "//pkg/scheduler/apis/config:go_default_library",
-        "//pkg/scheduler/factory:go_default_library",
         "//pkg/util/taints:go_default_library",
         "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/api/policy/v1beta1:go_default_library",

test/integration/scheduler/scheduler_test.go

@@ -42,7 +42,6 @@ import (
 	"k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
 	_ "k8s.io/kubernetes/pkg/scheduler/algorithmprovider"
 	kubeschedulerconfig "k8s.io/kubernetes/pkg/scheduler/apis/config"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
 	schedulerframework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
 	schedulernodeinfo "k8s.io/kubernetes/pkg/scheduler/nodeinfo"
 	"k8s.io/kubernetes/test/integration/framework"
@@ -86,10 +85,10 @@ func TestSchedulerCreationFromConfigMap(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(clientSet, 0)
 
 	// Pre-register some predicate and priority functions
-	factory.RegisterFitPredicate("PredicateOne", PredicateOne)
+	scheduler.RegisterFitPredicate("PredicateOne", PredicateOne)
-	factory.RegisterFitPredicate("PredicateTwo", PredicateTwo)
+	scheduler.RegisterFitPredicate("PredicateTwo", PredicateTwo)
-	factory.RegisterPriorityFunction("PriorityOne", PriorityOne, 1)
+	scheduler.RegisterPriorityFunction("PriorityOne", PriorityOne, 1)
-	factory.RegisterPriorityFunction("PriorityTwo", PriorityTwo, 1)
+	scheduler.RegisterPriorityFunction("PriorityTwo", PriorityTwo, 1)
 
 	for i, test := range []struct {
 		policy               string
@@ -255,7 +254,7 @@ priorities: []
 
 		sched, err := scheduler.New(clientSet,
 			informerFactory,
-			factory.NewPodInformer(clientSet, 0),
+			scheduler.NewPodInformer(clientSet, 0),
 			eventBroadcaster.NewRecorder(legacyscheme.Scheme, v1.DefaultSchedulerName),
 			kubeschedulerconfig.SchedulerAlgorithmSource{
 				Policy: &kubeschedulerconfig.SchedulerPolicySource{
@@ -318,7 +317,7 @@ func TestSchedulerCreationFromNonExistentConfigMap(t *testing.T) {
 
 	_, err := scheduler.New(clientSet,
 		informerFactory,
-		factory.NewPodInformer(clientSet, 0),
+		scheduler.NewPodInformer(clientSet, 0),
 		eventBroadcaster.NewRecorder(legacyscheme.Scheme, v1.DefaultSchedulerName),
 		kubeschedulerconfig.SchedulerAlgorithmSource{
 			Policy: &kubeschedulerconfig.SchedulerPolicySource{

test/integration/scheduler/util.go

@@ -55,7 +55,6 @@ import (
 	// Register defaults in pkg/scheduler/algorithmprovider.
 	_ "k8s.io/kubernetes/pkg/scheduler/algorithmprovider"
 	schedulerapi "k8s.io/kubernetes/pkg/scheduler/api"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
 	taintutils "k8s.io/kubernetes/pkg/util/taints"
 	"k8s.io/kubernetes/test/integration/framework"
 	imageutils "k8s.io/kubernetes/test/utils/image"
@@ -160,7 +159,7 @@ func initTestSchedulerWithOptions(
 
 	// create independent pod informer if required
 	if setPodInformer {
-		podInformer = factory.NewPodInformer(context.clientSet, 12*time.Hour)
+		podInformer = scheduler.NewPodInformer(context.clientSet, 12*time.Hour)
 	} else {
 		podInformer = context.informerFactory.Core().V1().Pods()
 	}

test/integration/scheduler_perf/BUILD

@@ -36,7 +36,7 @@ go_test(
     tags = ["integration"],
     deps = [
         "//pkg/features:go_default_library",
-        "//pkg/scheduler/factory:go_default_library",
+        "//pkg/scheduler:go_default_library",
         "//pkg/volume/util:go_default_library",
         "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/api/storage/v1beta1:go_default_library",

test/integration/scheduler_perf/scheduler_bench_test.go

@@ -33,7 +33,7 @@ import (
 	csilibplugins "k8s.io/csi-translation-lib/plugins"
 	"k8s.io/klog"
 	"k8s.io/kubernetes/pkg/features"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
+	"k8s.io/kubernetes/pkg/scheduler"
 	"k8s.io/kubernetes/pkg/volume/util"
 	"k8s.io/kubernetes/test/integration/framework"
 	testutils "k8s.io/kubernetes/test/utils"
@@ -364,7 +364,7 @@ func benchmarkScheduling(numNodes, numExistingPods, minPods int,
 	finalFunc, clientset := mustSetupScheduler()
 	defer finalFunc()
 
-	podInformer := factory.NewPodInformer(clientset, 0)
+	podInformer := scheduler.NewPodInformer(clientset, 0)
 	nodePreparer := framework.NewIntegrationTestNodePreparer(
 		clientset,
 		[]testutils.CountToStrategy{{Count: numNodes, Strategy: nodeStrategy}},

test/integration/scheduler_perf/scheduler_test.go

@@ -31,7 +31,7 @@ import (
 	coreinformers "k8s.io/client-go/informers/core/v1"
 	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/tools/cache"
-	"k8s.io/kubernetes/pkg/scheduler/factory"
+	"k8s.io/kubernetes/pkg/scheduler"
 	testutils "k8s.io/kubernetes/test/utils"
 
 	"k8s.io/klog"
@@ -138,7 +138,7 @@ func schedulePods(config *testConfig) int32 {
 	minQPS := int32(math.MaxInt32)
 	start := time.Now()
 
-	podInformer := factory.NewPodInformer(config.clientset, 0)
+	podInformer := scheduler.NewPodInformer(config.clientset, 0)
 	// Bake in time for the first pod scheduling event.
 	for {
 		time.Sleep(50 * time.Millisecond)