<?xml version="1.0" encoding="UTF-8"?>

<!--
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements.  See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership.  The ASF licenses this file
  ~ to you 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.
  -->

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

  <bean id="loggerManager" class="org.codehaus.plexus.logging.slf4j.Slf4jLoggerManager"
        init-method="initialize"/>

  <bean id="propertyConfigurer"
        class="org.codehaus.plexus.spring.PlexusServletContextPropertyPlaceholderConfigurer">
    <property name="locations">
      <list>
        <value>classpath:plexus.properties</value>
      </list>
    </property>
    <!-- ignore if plexus.properties not found -->
    <property name="ignoreResourceNotFound">
      <value>true</value>
    </property>
    <!-- ignore if a interpolated key not exists -->
    <property name="ignoreUnresolvablePlaceholders">
      <value>true</value>
    </property>
  </bean>

  <!-- to run builds in a chroot jail environment
       note this is not secure yet, see http://jira.codehaus.org/browse/CONTINUUM-1731 
  <bean name="chrootJailDirectory" class="java.io.File">
    <constructor-arg value="/home/jail"/>
  </bean>
  <bean id="workingDirectoryService" class="org.apache.maven.continuum.utils.ChrootJailWorkingDirectoryService" autowire="byName"/>
  -->

  <bean id="mailSession" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="java:comp/env/mail/Session">
    </property>
  </bean>

  <bean name="mailSender#continuum" class="org.springframework.mail.javamail.JavaMailSenderImpl">
    <property name="session" ref="mailSession"/>
  </bean>

  <bean name="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
    <property name="session" ref="mailSession"/>
  </bean>

  <bean id="masterBuildAgentTransportServer"
        class="org.apache.continuum.distributed.transport.master.MasterBuildAgentTransportServer">
    <constructor-arg ref="distributedBuildService"/>
  </bean>

  <bean name="xmlrpcServicesList" class="java.util.ArrayList">
    <constructor-arg>
      <list>
        <ref bean="masterBuildAgentTransportServer"/>
      </list>
    </constructor-arg>
  </bean>

  <!-- Redback Web Services -->
  <bean name="redbackRoleService" lazy-init="true" scope="singleton"
        class="org.codehaus.redback.xmlrpc.service.RoleServiceImpl">
    <constructor-arg ref="rBACManager#cached"/>
    <constructor-arg ref="roleManager"/>
  </bean>

  <bean name="redbackOperationService" lazy-init="true" scope="singleton"
        class="org.codehaus.redback.xmlrpc.service.OperationServiceImpl">
    <constructor-arg ref="rBACManager#cached"/>
  </bean>

  <bean name="redbackPermissionService" lazy-init="true" scope="singleton"
        class="org.codehaus.redback.xmlrpc.service.PermissionServiceImpl">
    <constructor-arg ref="rBACManager#cached"/>
  </bean>

  <bean name="redbackResourceService" lazy-init="true" scope="singleton"
        class="org.codehaus.redback.xmlrpc.service.ResourceServiceImpl">
    <constructor-arg ref="rBACManager#cached"/>
  </bean>

  <bean name="redbackUserService" lazy-init="true" scope="singleton"
        class="org.codehaus.redback.xmlrpc.service.UserServiceImpl">
    <constructor-arg ref="userManager#cached"/>
  </bean>

  <bean name="redbackXmlrpcServicesList" class="java.util.ArrayList">
    <constructor-arg>
      <list>
        <ref bean="redbackOperationService"/>
        <ref bean="redbackPermissionService"/>
        <ref bean="redbackResourceService"/>
        <ref bean="redbackRoleService"/>
        <ref bean="redbackUserService"/>
      </list>
    </constructor-arg>
  </bean>

  <bean name="redbackXmlRpcAuthenticator" class="org.codehaus.redback.xmlrpc.security.XmlRpcAuthenticator">
    <constructor-arg ref="securitySystem"/>
  </bean>

  <!-- triggers -->
  <bean id="continuumBuildTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
    <property name="jobDetail" ref="continuumBuildJob"/>
    <property name="cronExpression" value="0 * * * * ?"/>
  </bean>

  <!-- scheduler -->
  <bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property name="triggers">
      <list>
        <ref bean="continuumBuildTrigger"/>
      </list>
    </property>
    <property name="schedulerName" value="Continuum Scheduler"/>
    <property name="waitForJobsToCompleteOnShutdown" value="true"/>
    <property name="quartzProperties">
      <props>
        <prop key="org.quartz.threadPool.class">org.quartz.simpl.SimpleThreadPool</prop>
        <prop key="org.quartz.plugin.shutdownhook.class">org.quartz.plugins.management.ShutdownHookPlugin
        </prop>
        <prop key="org.quartz.plugin.shutdownhook.cleanShutdown">true</prop>
      </props>
    </property>
  </bean>

</beans>
