@@ -6,11 +6,17 @@ import (

 	"github.com/golang/glog"

 	kapi "k8s.io/kubernetes/pkg/api"

 	kerrors "k8s.io/kubernetes/pkg/api/errors"

+	"k8s.io/kubernetes/pkg/client/record"

+	kclient "k8s.io/kubernetes/pkg/client/unversioned"

 	utilruntime "k8s.io/kubernetes/pkg/util/runtime"

 	buildapi "github.com/openshift/origin/pkg/build/api"

 	buildclient "github.com/openshift/origin/pkg/build/client"

 	buildgenerator "github.com/openshift/origin/pkg/build/generator"

+	buildutil "github.com/openshift/origin/pkg/build/util"

+	"github.com/openshift/origin/pkg/client"

+	osclient "github.com/openshift/origin/pkg/client"

+	serverapi "github.com/openshift/origin/pkg/cmd/server/api"

 )

 // ConfigControllerFatalError represents a fatal error while generating a build.

@@ -33,11 +39,67 @@ func IsFatal(err error) bool {

 type BuildConfigController struct {

 	BuildConfigInstantiator buildclient.BuildConfigInstantiator

+

+	KubeClient kclient.Interface

+	Client     osclient.Interface

+

+	JenkinsConfig serverapi.JenkinsPipelineConfig

+

+	// recorder is used to record events.

+	Recorder record.EventRecorder

 }

 func (c *BuildConfigController) HandleBuildConfig(bc *buildapi.BuildConfig) error {

 	glog.V(4).Infof("Handling BuildConfig %s/%s", bc.Namespace, bc.Name)

+	if strategy := bc.Spec.Strategy.JenkinsPipelineStrategy; strategy != nil {

+		svcName := c.JenkinsConfig.ServiceName

+		if len(svcName) == 0 {

+			return fmt.Errorf("the Jenkins Pipeline ServiceName must be set in master configuration")

+		}

+

+		glog.V(4).Infof("Detected Jenkins pipeline strategy in %s/%s build configuration", bc.Namespace, bc.Name)

+		if _, err := c.KubeClient.Services(bc.Namespace).Get(svcName); err == nil {

+			glog.V(4).Infof("The Jenkins Pipeline service %q already exists in project %q", svcName, bc.Namespace)

+			return nil

+		}

+

+		isDisabled := c.JenkinsConfig.Disabled

+		if isDisabled != nil && *isDisabled {

+			glog.V(4).Infof("Provisioning Jenkins Pipeline from a template is disabled in master configuration")

+			return nil

+		}

+

+		glog.V(3).Infof("Adding new Jenkins service %q to the project %q", svcName, bc.Namespace)

+		kc, ok := c.KubeClient.(*kclient.Client)

+		if !ok {

+			return fmt.Errorf("unable to get kubernetes client from %v", c.KubeClient)

+		}

+		oc, ok := c.Client.(*client.Client)

+		if !ok {

+			return fmt.Errorf("unable to get openshift client from %v", c.KubeClient)

+		}

+

+		jenkinsTemplate := buildutil.NewJenkinsPipelineTemplate(bc.Namespace, c.JenkinsConfig, kc, oc)

+		objects, errs := jenkinsTemplate.Process()

+		if len(errs) > 0 {

+			for _, err := range errs {

+				c.Recorder.Eventf(bc, kapi.EventTypeWarning, "Failed", "Processing %s/%s error: %v", c.JenkinsConfig.Namespace, c.JenkinsConfig.TemplateName, err)

+			}

+			return fmt.Errorf("processing Jenkins pipeline template failed")

+		}

+

+		if errs := jenkinsTemplate.Instantiate(objects); len(errs) > 0 {

+			for _, err := range errs {

+				c.Recorder.Eventf(bc, kapi.EventTypeWarning, "Failed", "Instantiating %s/%s error: %v", c.JenkinsConfig.Namespace, c.JenkinsConfig.TemplateName, err)

+			}

+			return fmt.Errorf("instantiating Jenkins pipeline template failed")

+		}

+

+		c.Recorder.Eventf(bc, kapi.EventTypeNormal, "Started", "Jenkins Pipeline service %q created", svcName)

+		return nil

+	}

+

 	hasChangeTrigger := false

 	for _, trigger := range bc.Spec.Triggers {

 		if trigger.Type == buildapi.ConfigChangeBuildTriggerType {

new file mode 100644

@@ -0,0 +1,137 @@

+package util

+

+import (

+	"fmt"

+

+	"github.com/golang/glog"

+	"github.com/openshift/origin/pkg/api/latest"

+	"github.com/openshift/origin/pkg/client"

+	serverapi "github.com/openshift/origin/pkg/cmd/server/api"

+	"github.com/openshift/origin/pkg/config/cmd"

+	"github.com/openshift/origin/pkg/template"

+	templateapi "github.com/openshift/origin/pkg/template/api"

+	kapi "k8s.io/kubernetes/pkg/api"

+	kerrs "k8s.io/kubernetes/pkg/api/errors"

+	"k8s.io/kubernetes/pkg/api/meta"

+	"k8s.io/kubernetes/pkg/api/unversioned"

+	kclient "k8s.io/kubernetes/pkg/client/unversioned"

+	"k8s.io/kubernetes/pkg/kubectl/resource"

+	"k8s.io/kubernetes/pkg/runtime"

+)

+

+// JenkinsPipelineTemplate stores the configuration of the

+// JenkinsPipelineStrategy template, used to instantiate the Jenkins service in

+// given namespace.

+type JenkinsPipelineTemplate struct {

+	Config     serverapi.JenkinsPipelineConfig

+	Namespace  string

+	kubeClient *kclient.Client

+	osClient   *client.Client

+}

+

+// NewJenkinsPipelineTemplate returns a new JenkinsPipelineTemplate.

+func NewJenkinsPipelineTemplate(ns string, conf serverapi.JenkinsPipelineConfig, kubeClient *kclient.Client, osClient *client.Client) *JenkinsPipelineTemplate {

+	return &JenkinsPipelineTemplate{

+		Config:     conf,

+		Namespace:  ns,

+		kubeClient: kubeClient,

+		osClient:   osClient,

+	}

+}

+

+// Process processes the Jenkins template. If an error occurs

+func (t *JenkinsPipelineTemplate) Process() (*kapi.List, []error) {

+	var errors []error

+	jenkinsTemplate, err := t.osClient.Templates(t.Config.Namespace).Get(t.Config.TemplateName)

+	if err != nil {

+		if kerrs.IsNotFound(err) {

+			errors = append(errors, fmt.Errorf("Jenkins pipeline template %s/%s not found", t.Config.Namespace, t.Config.TemplateName))

+		} else {

+			errors = append(errors, err)

+		}

+		return nil, errors

+	}

+	errors = append(errors, substituteTemplateParameters(t.Config.Parameters, jenkinsTemplate)...)

+	pTemplate, err := t.osClient.TemplateConfigs(t.Namespace).Create(jenkinsTemplate)

+	if err != nil {

+		errors = append(errors, fmt.Errorf("processing Jenkins template %s/%s failed: %v", t.Config.Namespace, t.Config.TemplateName, err))

+		return nil, errors

+	}

+	var items []runtime.Object

+	for _, obj := range pTemplate.Objects {

+		if unknownObj, ok := obj.(*runtime.Unknown); ok {

+			decodedObj, err := runtime.Decode(kapi.Codecs.UniversalDecoder(), unknownObj.Raw)

+			if err != nil {

+				errors = append(errors, err)

+			}

+			items = append(items, decodedObj)

+		}

+	}

+	glog.V(4).Infof("Processed Jenkins pipeline jenkinsTemplate %s/%s", pTemplate.Namespace, pTemplate.Namespace)

+	return &kapi.List{ListMeta: unversioned.ListMeta{}, Items: items}, errors

+}

+

+// Instantiate instantiates the Jenkins template in the target namespace.

+func (t *JenkinsPipelineTemplate) Instantiate(list *kapi.List) []error {

+	var errors []error

+	if !t.hasJenkinsService(list) {

+		err := fmt.Errorf("template %s/%s does not contain required service %q", t.Config.Namespace, t.Config.TemplateName, t.Config.ServiceName)

+		return append(errors, err)

+	}

+	bulk := &cmd.Bulk{

+		Mapper: &resource.Mapper{

+			RESTMapper:  client.DefaultMultiRESTMapper(),

+			ObjectTyper: kapi.Scheme,

+			ClientMapper: resource.ClientMapperFunc(func(mapping *meta.RESTMapping) (resource.RESTClient, error) {

+				if latest.OriginKind(mapping.GroupVersionKind) {

+					return t.osClient, nil

+				}

+				return t.kubeClient, nil

+			}),

+		},

+		Op: cmd.Create,

+	}

+	return bulk.Run(list, t.Namespace)

+}

+

+// hasJenkinsService searches the template items and return true if the expected

+// Jenkins service is contained in template.

+func (t *JenkinsPipelineTemplate) hasJenkinsService(items *kapi.List) bool {

+	accessor := meta.NewAccessor()

+	for _, item := range items.Items {

+		kind, err := kapi.Scheme.ObjectKind(item)

+		if err != nil {

+			glog.Infof("Error checking Jenkins service kind: %v", err)

+			return false

+		}

+		name, err := accessor.Name(item)

+		if err != nil {

+			glog.Infof("Error checking Jenkins service name: %v", err)

+			return false

+		}

+		glog.Infof("Jenkins Pipeline template object %q with name %q", name, kind.Kind)

+		if name == t.Config.ServiceName && kind.Kind == "Service" {

+			return true

+		}

+	}

+	return false

+}

+

+// substituteTemplateParameters injects user specified parameter values into the Template

+func substituteTemplateParameters(params map[string]string, t *templateapi.Template) []error {

+	var errors []error

+	for name, value := range params {

+		if len(name) == 0 {

+			errors = append(errors, fmt.Errorf("template parameter name cannot be empty (%q)", value))

+			continue

+		}

+		if v := template.GetParameterByName(t, name); v != nil {

+			v.Value = value

+			v.Generate = ""

+			template.AddParameter(t, *v)

+		} else {

+			errors = append(errors, fmt.Errorf("unknown parameter %q specified for template", name))

+		}

+	}

+	return errors

+}

new file mode 100644

@@ -0,0 +1,26 @@

+package client

+

+import (

+	"k8s.io/kubernetes/pkg/api/meta"

+	"k8s.io/kubernetes/pkg/apimachinery/registered"

+	"k8s.io/kubernetes/pkg/util/sets"

+)

+

+// DefaultMultiRESTMapper returns the multi REST mapper with all OpenShift and

+// Kubernetes objects already registered.

+func DefaultMultiRESTMapper() meta.MultiRESTMapper {

+	var restMapper meta.MultiRESTMapper

+	seenGroups := sets.String{}

+	for _, gv := range registered.EnabledVersions() {

+		if seenGroups.Has(gv.Group) {

+			continue

+		}

+		seenGroups.Insert(gv.Group)

+		groupMeta, err := registered.Group(gv.Group)

+		if err != nil {

+			continue

+		}

+		restMapper = meta.MultiRESTMapper(append(restMapper, groupMeta.RESTMapper))

+	}

+	return restMapper

+}

@@ -288,6 +288,28 @@ type MasterConfig struct {

 	// VolumeConfig contains options for configuring volumes on the node.

 	VolumeConfig MasterVolumeConfig

+

+	// JenkinsPipelineConfig holds information about the default Jenkins template

+	// used for JenkinsPipeline build strategy.

+	JenkinsPipelineConfig JenkinsPipelineConfig

+}

+

+// JenkinsPipelineConfig holds configuration for the Jenkins pipeline strategy

+type JenkinsPipelineConfig struct {

+	// Disabled disables the Jenkins Pipeline auto-instantiation of Jenkins

+	// template. The ServiceName is still used to verify the project already have

+	// the Jenkins available. When not specified (default), this option defaults

+	// to false

+	Disabled *bool `json:"disabled"`

+	// Namespace contains the namespace name where the Jenkins template is stored

+	Namespace string

+	// TemplateName is the name of the default Jenkins template

+	TemplateName string

+	// ServiceName is the name of the Jenkins service OpenShift use for Jenkins

+	// pipeline

+	ServiceName string

+	// Parameters specifies a set of optional parameters to the Jenkins template

+	Parameters map[string]string

 }

 type ImagePolicyConfig struct {

@@ -32,6 +32,19 @@ func addDefaultingFuncs(scheme *runtime.Scheme) {

 			if len(obj.RoutingConfig.Subdomain) == 0 {

 				obj.RoutingConfig.Subdomain = "router.default.svc.cluster.local"

 			}

+			if len(obj.JenkinsPipelineConfig.Namespace) == 0 {

+				obj.JenkinsPipelineConfig.Namespace = "openshift"

+			}

+			if len(obj.JenkinsPipelineConfig.TemplateName) == 0 {

+				obj.JenkinsPipelineConfig.TemplateName = "jenkins"

+			}

+			if len(obj.JenkinsPipelineConfig.ServiceName) == 0 {

+				obj.JenkinsPipelineConfig.ServiceName = "jenkins"

+			}

+			if obj.JenkinsPipelineConfig.Disabled == nil {

+				disabled := false

+				obj.JenkinsPipelineConfig.Disabled = &disabled

+			}

 			// Populate the new NetworkConfig.ServiceNetworkCIDR field from the KubernetesMasterConfig.ServicesSubnet field if needed

 			if len(obj.NetworkConfig.ServiceNetworkCIDR) == 0 {

@@ -265,6 +265,19 @@ func (ImagePolicyConfig) SwaggerDoc() map[string]string {

 	return map_ImagePolicyConfig

 }

+var map_JenkinsPipelineConfig = map[string]string{

+	"":             "JenkinsPipelineConfig holds configuration for the Jenkins pipeline strategy",

+	"disabled":     "Disabled disables the Jenkins Pipeline auto-instantiation of Jenkins template. The ServiceName is still used to verify the project already have the Jenkins available. When not specified (default), this option defaults to false",

+	"namespace":    "Namespace contains the namespace name where the Jenkins template is stored",

+	"templateName": "TemplateName is the name of the default Jenkins template",

+	"serviceName":  "ServiceName is the name of the Jenkins service OpenShift use for Jenkins pipeline",

+	"parameters":   "Parameters specifies a set of optional parameters to the Jenkins template",

+}

+

+func (JenkinsPipelineConfig) SwaggerDoc() map[string]string {

+	return map_JenkinsPipelineConfig

+}

+

 var map_KeystonePasswordIdentityProvider = map[string]string{

 	"":           "KeystonePasswordIdentityProvider provides identities for users authenticating using keystone password credentials",

 	"domainName": "Domain Name is required for keystone v3",

@@ -409,6 +422,7 @@ var map_MasterConfig = map[string]string{

 	"routingConfig":          "RoutingConfig holds information about routing and route generation",

 	"networkConfig":          "NetworkConfig to be passed to the compiled in network plugin",

 	"volumeConfig":           "MasterVolumeConfig contains options for configuring volume plugins in the master node.",

+	"jenkinsPipelineConfig":  "JenkinsPipelineConfig holds information about the default Jenkins template used for JenkinsPipeline build strategy.",

 }

 func (MasterConfig) SwaggerDoc() map[string]string {

@@ -228,6 +228,28 @@ type MasterConfig struct {

 	// MasterVolumeConfig contains options for configuring volume plugins in the master node.

 	VolumeConfig MasterVolumeConfig `json:"volumeConfig"`

+

+	// JenkinsPipelineConfig holds information about the default Jenkins template

+	// used for JenkinsPipeline build strategy.

+	JenkinsPipelineConfig JenkinsPipelineConfig `json:"jenkinsPipelineConfig"`

+}

+

+// JenkinsPipelineConfig holds configuration for the Jenkins pipeline strategy

+type JenkinsPipelineConfig struct {

+	// Disabled disables the Jenkins Pipeline auto-instantiation of Jenkins

+	// template. The ServiceName is still used to verify the project already have

+	// the Jenkins available. When not specified (default), this option defaults

+	// to false

+	Disabled *bool `json:"disabled"`

+	// Namespace contains the namespace name where the Jenkins template is stored

+	Namespace string `json:"namespace"`

+	// TemplateName is the name of the default Jenkins template

+	TemplateName string `json:"templateName"`

+	// ServiceName is the name of the Jenkins service OpenShift use for Jenkins

+	// pipeline

+	ServiceName string `json:"serviceName"`

+	// Parameters specifies a set of optional parameters to the Jenkins template

+	Parameters map[string]string `json:"parameters"`

 }

 // ImagePolicyConfig holds the necessary configuration options for limits and behavior for importing images

@@ -270,9 +270,14 @@ func (c *MasterConfig) RunBuildImageChangeTriggerController() {

 // RunBuildConfigChangeController starts the build config change trigger controller process.

 func (c *MasterConfig) RunBuildConfigChangeController() {

-	bcClient, _ := c.BuildConfigChangeControllerClients()

+	bcClient, kClient := c.BuildConfigChangeControllerClients()

 	bcInstantiator := buildclient.NewOSClientBuildConfigInstantiatorClient(bcClient)

-	factory := buildcontrollerfactory.BuildConfigControllerFactory{Client: bcClient, BuildConfigInstantiator: bcInstantiator}

+	factory := buildcontrollerfactory.BuildConfigControllerFactory{

+		Client:                  bcClient,

+		KubeClient:              kClient,

+		BuildConfigInstantiator: bcInstantiator,

+		JenkinsConfig:           c.Options.JenkinsPipelineConfig,

+	}

 	factory.Create().Run()

 }

@@ -11,7 +11,6 @@ import (

 	"k8s.io/kubernetes/pkg/api/meta"

 	"k8s.io/kubernetes/pkg/api/rest"

 	"k8s.io/kubernetes/pkg/api/unversioned"

-	"k8s.io/kubernetes/pkg/apimachinery/registered"

 	kclient "k8s.io/kubernetes/pkg/client/unversioned"

 	"k8s.io/kubernetes/pkg/kubectl/resource"

 	"k8s.io/kubernetes/pkg/runtime"

@@ -138,24 +137,9 @@ func (r *REST) Create(ctx kapi.Context, obj runtime.Object) (runtime.Object, err

 		return nil, err

 	}

-	var restMapper meta.MultiRESTMapper

-	seenGroups := sets.String{}

-	for _, gv := range registered.EnabledVersions() {

-		if seenGroups.Has(gv.Group) {

-			continue

-		}

-		seenGroups.Insert(gv.Group)

-

-		groupMeta, err := registered.Group(gv.Group)

-		if err != nil {

-			continue

-		}

-		restMapper = meta.MultiRESTMapper(append(restMapper, groupMeta.RESTMapper))

-	}

-

 	bulk := configcmd.Bulk{

 		Mapper: &resource.Mapper{

-			RESTMapper:  restMapper,

+			RESTMapper:  client.DefaultMultiRESTMapper(),

 			ObjectTyper: kapi.Scheme,

 			ClientMapper: resource.ClientMapperFunc(func(mapping *meta.RESTMapping) (resource.RESTClient, error) {

 				if latest.OriginKind(mapping.GroupVersionKind) {