deploy: remove generic trigger controller

pkg/cmd/server/bootstrappolicy/controller_policy.go

@@ -95,18 +95,6 @@ func init() {
 			rbac.NewRule("create", "get", "list", "watch", "update", "patch", "delete").Groups(kapiGroup).Resources("replicationcontrollers").RuleOrDie(),
 			rbac.NewRule("update").Groups(deployGroup, legacyDeployGroup).Resources("deploymentconfigs/status").RuleOrDie(),
 			rbac.NewRule("get", "list", "watch").Groups(deployGroup, legacyDeployGroup).Resources("deploymentconfigs").RuleOrDie(),
-			eventsRule(),
-		},
-	})
-
-	// deployment-trigger-controller
-	addControllerRole(rbac.ClusterRole{
-		ObjectMeta: metav1.ObjectMeta{Name: saRolePrefix + InfraDeploymentTriggerControllerServiceAccountName},
-		Rules: []rbac.PolicyRule{
-			rbac.NewRule("get", "list", "watch").Groups(kapiGroup).Resources("replicationcontrollers").RuleOrDie(),
-			rbac.NewRule("get", "list", "watch").Groups(deployGroup, legacyDeployGroup).Resources("deploymentconfigs").RuleOrDie(),
-			rbac.NewRule("get", "list", "watch").Groups(imageGroup, legacyImageGroup).Resources("imagestreams").RuleOrDie(),
-
 			rbac.NewRule("create").Groups(deployGroup, legacyDeployGroup).Resources("deploymentconfigs/instantiate").RuleOrDie(),
 			eventsRule(),
 		},

pkg/cmd/server/bootstrappolicy/infra_sa_policy.go

@@ -29,7 +29,6 @@ const (
 	InfraBuildControllerServiceAccountName                      = "build-controller"
 	InfraBuildConfigChangeControllerServiceAccountName          = "build-config-change-controller"
 	InfraDeploymentConfigControllerServiceAccountName           = "deploymentconfig-controller"
-	InfraDeploymentTriggerControllerServiceAccountName          = "deployment-trigger-controller"
 	InfraDeployerControllerServiceAccountName                   = "deployer-controller"
 	InfraImageTriggerControllerServiceAccountName               = "image-trigger-controller"
 	InfraImageImportControllerServiceAccountName                = "image-import-controller"

pkg/cmd/server/origin/controller.go

@@ -188,9 +188,6 @@ func (c *MasterConfig) NewOpenshiftControllerInitializers() (map[string]controll
 	deploymentConfig := controller.DeploymentConfigControllerConfig{Codec: codec}
 	ret["openshift.io/deploymentconfig"] = deploymentConfig.RunController
 
-	deploymentTrigger := controller.DeploymentTriggerControllerConfig{Codec: codec}
-	ret["openshift.io/deploymenttrigger"] = deploymentTrigger.RunController
-
 	// initialize other controllers
 	imageTrigger := controller.ImageTriggerControllerConfig{
 		HasBuilderEnabled: c.Options.DisabledFeatures.Has(configapi.FeatureBuilder),

pkg/cmd/server/origin/controller/apps.go

@@ -7,7 +7,6 @@ import (
 	"github.com/openshift/origin/pkg/cmd/server/bootstrappolicy"
 	deployercontroller "github.com/openshift/origin/pkg/deploy/controller/deployer"
 	deployconfigcontroller "github.com/openshift/origin/pkg/deploy/controller/deploymentconfig"
-	triggercontroller "github.com/openshift/origin/pkg/deploy/controller/generictrigger"
 )
 
 type DeployerControllerConfig struct {
@@ -21,10 +20,6 @@ type DeploymentConfigControllerConfig struct {
 	Codec runtime.Codec
 }
 
-type DeploymentTriggerControllerConfig struct {
-	Codec runtime.Codec
-}
-
 func (c *DeployerControllerConfig) RunController(ctx ControllerContext) (bool, error) {
 	kubeClient, err := ctx.ClientBuilder.Client(bootstrappolicy.InfraDeployerControllerServiceAccountName)
 	if err != nil {
@@ -66,22 +61,3 @@ func (c *DeploymentConfigControllerConfig) RunController(ctx ControllerContext)
 
 	return true, nil
 }
-
-func (c *DeploymentTriggerControllerConfig) RunController(ctx ControllerContext) (bool, error) {
-	saName := bootstrappolicy.InfraDeploymentTriggerControllerServiceAccountName
-
-	deprecatedOcTriggerClient, err := ctx.ClientBuilder.DeprecatedOpenshiftClient(saName)
-	if err != nil {
-		return true, err
-	}
-
-	go triggercontroller.NewDeploymentTriggerController(
-		ctx.AppInformers.Apps().InternalVersion().DeploymentConfigs().Informer(),
-		ctx.ExternalKubeInformers.Core().V1().ReplicationControllers().Informer(),
-		ctx.ImageInformers.Image().InternalVersion().ImageStreams().Informer(),
-		deprecatedOcTriggerClient,
-		c.Codec,
-	).Run(5, ctx.Stop)
-
-	return true, nil
-}

pkg/cmd/server/start/start_master.go

@@ -812,7 +812,6 @@ func startControllers(oc *origin.MasterConfig, kc *kubernetes.MasterConfig) erro
 		"openshift.io/origin-namespace",
 		"openshift.io/deployer",
 		"openshift.io/deploymentconfig",
-		"openshift.io/deploymenttrigger",
 		"openshift.io/image-trigger",
 		"openshift.io/image-import",
 		"openshift.io/service-serving-cert",

pkg/deploy/controller/deploymentconfig/deploymentconfig_controller.go

@@ -63,6 +63,8 @@ type DeploymentConfigController struct {
 
 	// queue contains deployment configs that need to be synced.
 	queue workqueue.RateLimitingInterface
+	// instantiateQueue contains deployment config that should be instantiated.
+	instantiateQueue workqueue.RateLimitingInterface
 
 	// dcStore provides a local cache for deployment configs.
 	dcStore oscache.StoreToDeploymentConfigLister

pkg/deploy/controller/deploymentconfig/factory.go

@@ -2,9 +2,11 @@ package deploymentconfig
 
 import (
 	"fmt"
+	"reflect"
 	"time"
 
 	"github.com/golang/glog"
+	kapierrs "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/runtime"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/util/wait"
@@ -22,6 +24,7 @@ import (
 	osclient "github.com/openshift/origin/pkg/client"
 	oscontroller "github.com/openshift/origin/pkg/controller"
 	deployapi "github.com/openshift/origin/pkg/deploy/apis/apps"
+	deployutil "github.com/openshift/origin/pkg/deploy/util"
 )
 
 const (
@@ -47,7 +50,8 @@ func NewDeploymentConfigController(
 		dn: oc,
 		rn: kubeClientset.Core(),
 
-		queue: workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()),
+		queue:            workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()),
+		instantiateQueue: workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter()),
 
 		rcLister:       rcInformer.Lister(),
 		rcListerSynced: rcInformer.Informer().HasSynced,
@@ -92,16 +96,33 @@ func (c *DeploymentConfigController) Run(workers int, stopCh <-chan struct{}) {
 
 	for i := 0; i < workers; i++ {
 		go wait.Until(c.worker, time.Second, stopCh)
+		go wait.Until(c.instantiateWorker, time.Second, stopCh)
 	}
 
 	<-stopCh
 
 	glog.Infof("Shutting down deploymentconfig controller")
 }
 
+// processConfigChange checks if we should trigger a new deployment if the deployment
+// config has a config change trigger enabled and the template changed.
+func processConfigChange(oldDc, newDc *deployapi.DeploymentConfig) bool {
+	if !deployutil.HasChangeTrigger(newDc) {
+		return false
+	}
+	// initial rollout
+	if oldDc == nil {
+		return true
+	}
+	return !reflect.DeepEqual(newDc.Spec.Template, oldDc.Spec.Template)
+}
+
 func (c *DeploymentConfigController) addDeploymentConfig(obj interface{}) {
 	dc := obj.(*deployapi.DeploymentConfig)
 	glog.V(4).Infof("Adding deployment config %q", dc.Name)
+	if processConfigChange(nil, dc) {
+		c.enqueueDeploymentConfigInstantiate(dc)
+	}
 	c.enqueueDeploymentConfig(dc)
 }
 
@@ -112,8 +133,11 @@ func (c *DeploymentConfigController) updateDeploymentConfig(old, cur interface{}
 	if newDc.ResourceVersion == oldDc.ResourceVersion {
 		return
 	}
-
 	glog.V(4).Infof("Updating deployment config %q", newDc.Name)
+
+	if processConfigChange(oldDc, newDc) {
+		c.enqueueDeploymentConfigInstantiate(newDc)
+	}
 	c.enqueueDeploymentConfig(newDc)
 }
 
@@ -185,6 +209,16 @@ func (c *DeploymentConfigController) enqueueDeploymentConfig(dc *deployapi.Deplo
 	c.queue.Add(key)
 }
 
+func (c *DeploymentConfigController) enqueueDeploymentConfigInstantiate(dc *deployapi.DeploymentConfig) {
+	key, err := kcontroller.KeyFunc(dc)
+	if err != nil {
+		utilruntime.HandleError(fmt.Errorf("Couldn't get key for object %#v: %v", dc, err))
+		return
+	}
+	glog.V(4).Infof("Detected config change in deployment config %s/%s, queueing for instantiate (current version: %d)", dc.Namespace, dc.Name, dc.Status.LatestVersion)
+	c.instantiateQueue.Add(key)
+}
+
 func (c *DeploymentConfigController) worker() {
 	for {
 		if quit := c.work(); quit {
@@ -193,6 +227,42 @@ func (c *DeploymentConfigController) worker() {
 	}
 }
 
+func (c *DeploymentConfigController) instantiateWorker() {
+	for {
+		if quit := c.instantiate(); quit {
+			return
+		}
+	}
+}
+
+func (c *DeploymentConfigController) instantiate() bool {
+	key, quit := c.instantiateQueue.Get()
+	if quit {
+		return true
+	}
+	defer c.instantiateQueue.Done(key)
+
+	dc, err := c.getByKey(key.(string))
+	if err != nil {
+		utilruntime.HandleError(err)
+	}
+
+	if dc == nil {
+		return false
+	}
+
+	if _, err := c.dn.DeploymentConfigs(dc.Namespace).Instantiate(deployutil.DefaultInstantiateRequestForConfig(dc.Name)); err != nil {
+		if kapierrs.IsConflict(err) && c.instantiateQueue.NumRequeues(key) < maxRetryCount {
+			c.instantiateQueue.AddRateLimited(key)
+			return false
+		}
+		glog.V(4).Infof("Failed to instantiate %s/%s: %v", dc.Namespace, dc.Name, err)
+	}
+
+	c.instantiateQueue.Forget(key)
+	return false
+}
+
 func (c *DeploymentConfigController) work() bool {
 	key, quit := c.queue.Get()
 	if quit {

pkg/deploy/util/util.go

@@ -704,6 +704,14 @@ func WaitForRunningDeployerPod(podClient kcoreclient.PodsGetter, rc *api.Replica
 	return nil
 }
 
+func DefaultInstantiateRequestForConfig(configName string) *deployapi.DeploymentRequest {
+	return &deployapi.DeploymentRequest{
+		Name:   configName,
+		Latest: true,
+		Force:  false,
+	}
+}
+
 // ByLatestVersionAsc sorts deployments by LatestVersion ascending.
 type ByLatestVersionAsc []*api.ReplicationController