func (a *jenkinsBootstrapper) Admit(attributes admission.Attributes) error {
if a.jenkinsConfig.AutoProvisionEnabled != nil && !*a.jenkinsConfig.AutoProvisionEnabled {
return nil
}
if len(attributes.GetSubresource()) != 0 {
return nil
}
if attributes.GetResource().GroupResource() != buildapi.Resource("buildconfigs") && attributes.GetResource().GroupResource() != buildapi.Resource("builds") {
return nil
}
if !needsJenkinsTemplate(attributes.GetObject()) {
return nil
}
namespace := attributes.GetNamespace()
svcName := a.jenkinsConfig.ServiceName
if len(svcName) == 0 {
return nil
}
// TODO pull this from a cache.
if _, err := a.serviceClient.Services(namespace).Get(svcName); !kapierrors.IsNotFound(err) {
// if it isn't a "not found" error, return the error. Either its nil and there's nothing to do or something went really wrong
return err
}
glog.V(3).Infof("Adding new jenkins service %q to the project %q", svcName, namespace)
jenkinsTemplate := jenkinscontroller.NewPipelineTemplate(namespace, a.jenkinsConfig, a.openshiftClient)
objects, errs := jenkinsTemplate.Process()
if len(errs) > 0 {
return kutilerrors.NewAggregate(errs)
}
if !jenkinsTemplate.HasJenkinsService(objects) {
return fmt.Errorf("template %s/%s does not contain required service %q", a.jenkinsConfig.TemplateNamespace, a.jenkinsConfig.TemplateName, a.jenkinsConfig.ServiceName)
}
impersonatingConfig := a.privilegedRESTClientConfig
oldWrapTransport := impersonatingConfig.WrapTransport
impersonatingConfig.WrapTransport = func(rt http.RoundTripper) http.RoundTripper {
return authenticationclient.NewImpersonatingRoundTripper(attributes.GetUserInfo(), oldWrapTransport(rt))
}
var bulkErr error
bulk := &cmd.Bulk{
Mapper: &resource.Mapper{
RESTMapper: registered.RESTMapper(),
ObjectTyper: kapi.Scheme,
ClientMapper: resource.ClientMapperFunc(func(mapping *meta.RESTMapping) (resource.RESTClient, error) {
if latest.OriginKind(mapping.GroupVersionKind) {
return client.New(&impersonatingConfig)
}
return kclient.New(&impersonatingConfig)
}),
},
Op: cmd.Create,
After: func(info *resource.Info, err error) bool {
if kapierrors.IsAlreadyExists(err) {
return false
}
if err != nil {
bulkErr = err
return true
}
return false
},
}
// we're intercepting the error we care about using After
bulk.Run(objects, namespace)
if bulkErr != nil {
return bulkErr
}
glog.V(1).Infof("Jenkins Pipeline service %q created", svcName)
return nil
}
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
}
if b := c.JenkinsConfig.Enabled; b == nil || !*b {
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 := jenkins.NewPipelineTemplate(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.TemplateNamespace, 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.TemplateNamespace, 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 {
hasChangeTrigger = true
break
}
}
if !hasChangeTrigger {
return nil
}
if bc.Status.LastVersion > 0 {
return nil
}
glog.V(4).Infof("Running build for BuildConfig %s/%s", bc.Namespace, bc.Name)
// instantiate new build
lastVersion := 0
request := &buildapi.BuildRequest{
ObjectMeta: kapi.ObjectMeta{
Name: bc.Name,
Namespace: bc.Namespace,
},
LastVersion: &lastVersion,
}
if _, err := c.BuildConfigInstantiator.Instantiate(bc.Namespace, request); err != nil {
var instantiateErr error
if kerrors.IsConflict(err) {
instantiateErr = fmt.Errorf("unable to instantiate Build for BuildConfig %s/%s due to a conflicting update: %v", bc.Namespace, bc.Name, err)
utilruntime.HandleError(instantiateErr)
} else if buildgenerator.IsFatal(err) {
return &ConfigControllerFatalError{err.Error()}
} else {
instantiateErr = fmt.Errorf("error instantiating Build from BuildConfig %s/%s: %v", bc.Namespace, bc.Name, err)
utilruntime.HandleError(instantiateErr)
}
return instantiateErr
}
return nil
}
