Example usage for org.springframework.beans.factory.support BeanDefinitionBuilder addPropertyReference

List of usage examples for org.springframework.beans.factory.support BeanDefinitionBuilder addPropertyReference

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.support.*
  5. BeanDefinitionBuilder
  6. addPropertyReference

Introduction

In this page you can find the example usage for org.springframework.beans.factory.support BeanDefinitionBuilder addPropertyReference.

Prototype

public BeanDefinitionBuilder addPropertyReference(String name, String beanName)

Source Link

Document

Add a reference to the specified bean name under the property specified.

Usage

From source file:org.opencredo.couchdb.config.CouchDbOutboundChannelAdapterParser.java

@Override
protected AbstractBeanDefinition parseConsumer(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder
            .genericBeanDefinition(CouchDbSendingMessageHandler.class);
    String databaseUrl = element.getAttribute(COUCHDB_DATABASE_URL_ATTRIBUTE);
    String documentOperations = element.getAttribute(COUCHDB_DOCUMENT_OPERATIONS_ATTRIBUTE);
    String documentIdExpression = element.getAttribute(COUCHDB_DOCUMENT_ID_EXPRESSION_ATTRIBUTE);
    String exeptionsCounter = element.getAttribute(COUCHDB_EXCEPTIONS_COUNTER);

    if (StringUtils.hasText(databaseUrl)) {
        if (StringUtils.hasText(documentOperations)) {
            parserContext.getReaderContext().error("At most one of '" + COUCHDB_DATABASE_URL_ATTRIBUTE
                    + "' and '" + COUCHDB_DOCUMENT_OPERATIONS_ATTRIBUTE + "' may be provided.", element);
        } else {/*from  w  ww.j av  a  2s  .c o  m*/
            builder.addConstructorArgValue(databaseUrl);
        }
    } else if (StringUtils.hasText(documentOperations)) {
        builder.addConstructorArgReference(documentOperations);
    } else {
        parserContext.getReaderContext().error("Either '" + COUCHDB_DATABASE_URL_ATTRIBUTE + "' or '"
                + COUCHDB_DOCUMENT_OPERATIONS_ATTRIBUTE + "' must be provided.", element);
    }

    if (StringUtils.hasText(documentIdExpression)) {
        builder.addPropertyValue(COUCHDB_DOCUMENT_ID_EXPRESSION_PROPERTY, documentIdExpression);
    }

    if (StringUtils.hasText(exeptionsCounter)) {
        builder.addPropertyReference("counter", exeptionsCounter);
    }

    return builder.getBeanDefinition();
}

From source file:de.gwdg.shibboleth.config.attribute.resolver.dataConnector.MailmanDataConnectorBeanDefinitionParser.java

/** {@inheritDoc} */
protected void doParse(String pluginId, Element pluginConfig, Map<QName, List<Element>> pluginConfigChildren,
        BeanDefinitionBuilder pluginBuilder, ParserContext parserContext) {
    super.doParse(pluginId, pluginConfig, pluginConfigChildren, pluginBuilder, parserContext);

    String mailmanHost = pluginConfig.getAttributeNS(null, "mailmanHost");
    log.info("mailman connector {} mailman HOST: {}", pluginId, mailmanHost);
    pluginBuilder.addPropertyValue("mailmanHost", mailmanHost);

    String mailmanPort = pluginConfig.getAttributeNS(null, "mailmanPort");
    log.info("mailman connector {} mailman PORT: {}", pluginId, mailmanPort);
    pluginBuilder.addPropertyValue("mailmanPort", mailmanPort);

    String username = pluginConfig.getAttributeNS(null, "username");
    log.info("mailman connector {} mailman USERNAME: {}", pluginId, username);
    pluginBuilder.addPropertyValue("username", username);

    String password = pluginConfig.getAttributeNS(null, "password");
    pluginBuilder.addPropertyValue("password", password);

    Map<String, String> keyAttributeMaps = parseAttributeMappings(pluginId, pluginConfigChildren,
            pluginBuilder);/*from   w ww .j a  va2 s.c  om*/
    pluginBuilder.addPropertyValue("keyAttributeMap", keyAttributeMaps);

    String queryTemplate = pluginConfigChildren.get(QUERY_TEMPLATE_ELEMENT_NAME).get(0).getTextContent();
    queryTemplate = DatatypeHelper.safeTrimOrNullString(queryTemplate);
    log.debug("mailman connector {} query template: {}", pluginId, queryTemplate);
    pluginBuilder.addPropertyValue("queryTemplate", queryTemplate);

    String templateEngineRef = pluginConfig.getAttributeNS(null, "templateEngine");
    pluginBuilder.addPropertyReference("templateEngine", templateEngineRef);
}

From source file:nats.client.spring.config.NatsBeanDefinitionParser.java

@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
    final BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(NatsFactoryBean.class);

    // Parse list of hosts
    final List<String> uris = new ManagedList<>();
    final List<Element> hosts = DomUtils.getChildElementsByTagName(element, ELEMENT_URL);
    for (Element host : hosts) {
        uris.add(host.getTextContent());
    }/*from  www.  ja v  a  2 s .c o m*/
    builder.addPropertyValue("hostUris", uris);

    // Parse list of subscriptions
    final List<BeanDefinition> subscriptions = new ManagedList<>();
    final List<Element> subscriptionElements = DomUtils.getChildElementsByTagName(element,
            ELEMENT_SUBSCRIPTION);
    for (Element subscriptionElement : subscriptionElements) {
        final BeanDefinitionBuilder subscriptionBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(SubscriptionConfig.class);
        subscriptionBuilder.addConstructorArgValue(subscriptionElement.getAttribute(ATTRIBUTE_SUBJECT));
        subscriptionBuilder.addConstructorArgReference(subscriptionElement.getAttribute(ATTRIBUTE_REF));
        subscriptionBuilder.addConstructorArgValue(subscriptionElement.getAttribute(ATTRIBUTE_METHOD));
        subscriptionBuilder.addConstructorArgValue(subscriptionElement.getAttribute(ATTRIBUTE_QUEUE_GROUP));
        subscriptions.add(subscriptionBuilder.getBeanDefinition());
    }
    builder.addPropertyValue("subscriptions", subscriptions);

    // Parse attributes
    builder.addPropertyValue("autoReconnect", element.getAttribute(ATTRIBUTE_AUTO_RECONNECT));
    builder.addPropertyValue("reconnectWaitTime", element.getAttribute(ATTRIBUTE_RECONNECT_WAIT_TIME));
    final String eventLoopGroupRef = element.getAttribute(ATTRIBUTE_EVENT_LOOP_GROUP_REF);
    if (StringUtils.hasText(eventLoopGroupRef)) {
        builder.addPropertyReference("eventLoopGroup", eventLoopGroupRef);
    }
    final String callbackExecutorRef = element.getAttribute(ATTRIBUTE_CALLBACK_EXECUTOR_REF);
    if (StringUtils.hasText(callbackExecutorRef)) {
        builder.addPropertyReference("callbackExecutor", callbackExecutorRef);
    }
    final String connectionStateListenerRef = element.getAttribute(ATTRIBUTE_CONNECTION_STATE_LISTENER_REF);
    if (StringUtils.hasText(connectionStateListenerRef)) {
        builder.addPropertyReference("connectionStateListener", connectionStateListenerRef);
    }

    // Register bean
    final String id = element.getAttribute(ATTRIBUTE_ID);

    final AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
    parserContext.getRegistry().registerBeanDefinition(id, beanDefinition);

    return beanDefinition;
}

From source file:edu.internet2.middleware.shibboleth.common.config.attribute.resolver.dataConnector.LdapDataConnectorBeanDefinitionParser.java

/**
 * Processes the cache configuration directives.
 * /*ww  w.  java  2s. co  m*/
 * @param pluginId ID of the plugin
 * @param pluginConfig configuration element for the plugin
 * @param pluginBuilder builder for the plugin
 */
protected void processCacheConfig(String pluginId, Element pluginConfig, BeanDefinitionBuilder pluginBuilder) {
    boolean cacheResults = false;
    String cacheManagerId = "shibboleth.CacheManager";
    long cacheElementTtl = 4 * 60 * 60 * 1000;
    int maximumCachedElements = 500;

    List<Element> cacheConfigs = XMLHelper.getChildElementsByTagNameNS(pluginConfig,
            DataConnectorNamespaceHandler.NAMESPACE, "ResultCache");
    if (cacheConfigs != null && !cacheConfigs.isEmpty()) {
        Element cacheConfig = cacheConfigs.get(0);

        cacheResults = true;

        if (cacheConfig.hasAttributeNS(null, "cacheManagerRef")) {
            cacheManagerId = DatatypeHelper.safeTrim(cacheConfig.getAttributeNS(null, "cacheManagerRef"));
        }

        if (cacheConfig.hasAttributeNS(null, "elementTimeToLive")) {
            cacheElementTtl = SpringConfigurationUtils.parseDurationToMillis(
                    "elementTimeToLive on data connector " + pluginId,
                    cacheConfig.getAttributeNS(null, "elementTimeToLive"), 0);
        }

        if (cacheConfig.hasAttributeNS(null, "maximumCachedElements")) {
            maximumCachedElements = Integer.parseInt(
                    DatatypeHelper.safeTrim(cacheConfig.getAttributeNS(null, "maximumCachedElements")));
        }
    }

    if (pluginConfig.hasAttributeNS(null, "cacheResults")) {
        log.warn(
                "Data connection {}: use of 'cacheResults' attribute is deprecated.  Use <ResultCache> instead.",
                pluginId);
        cacheResults = XMLHelper
                .getAttributeValueAsBoolean(pluginConfig.getAttributeNodeNS(null, "cacheResults"));
    }

    if (cacheResults) {
        log.debug("Data connector {} is caching results: {}", pluginId, cacheResults);

        pluginBuilder.addPropertyReference("cacheManager", cacheManagerId);

        log.debug("Data connector {} cache element time to live: {}ms", pluginId, cacheElementTtl);
        pluginBuilder.addPropertyValue("cacheElementTimeToLive", cacheElementTtl);

        log.debug("Data connector {} maximum number of caches elements: {}", pluginId, maximumCachedElements);
        pluginBuilder.addPropertyValue("maximumCachedElements", maximumCachedElements);
    }

}

From source file:edu.internet2.middleware.shibboleth.common.config.attribute.resolver.dataConnector.RDBMSDataConnectorBeanDefinitionParser.java

/**
 * Processes the cache configuration options.
 * /*from w w w.  jav  a2  s  . c  om*/
 * @param pluginId ID of the data connector
 * @param pluginConfig configuration element for the data connector
 * @param pluginConfigChildren child config elements for the data connect
 * @param pluginBuilder builder of the data connector
 * @param parserContext current configuration parsing context
 */
protected void processCacheConfig(String pluginId, Element pluginConfig,
        Map<QName, List<Element>> pluginConfigChildren, BeanDefinitionBuilder pluginBuilder,
        ParserContext parserContext) {
    boolean cacheResults = false;
    String cacheManagerId = "shibboleth.CacheManager";
    long cacheElementTtl = 4 * 60 * 60 * 1000;
    int maximumCachedElements = 500;

    List<Element> cacheConfigs = XMLHelper.getChildElementsByTagNameNS(pluginConfig,
            DataConnectorNamespaceHandler.NAMESPACE, "ResultCache");
    if (cacheConfigs != null && !cacheConfigs.isEmpty()) {
        Element cacheConfig = cacheConfigs.get(0);

        cacheResults = true;

        if (cacheConfig.hasAttributeNS(null, "cacheManagerRef")) {
            cacheManagerId = DatatypeHelper.safeTrim(cacheConfig.getAttributeNS(null, "cacheManagerRef"));
        }

        if (cacheConfig.hasAttributeNS(null, "elementTimeToLive")) {
            cacheElementTtl = SpringConfigurationUtils.parseDurationToMillis(
                    "elementTimeToLive on data connector " + pluginId,
                    cacheConfig.getAttributeNS(null, "elementTimeToLive"), 0);
        }

        if (cacheConfig.hasAttributeNS(null, "maximumCachedElements")) {
            maximumCachedElements = Integer.parseInt(
                    DatatypeHelper.safeTrim(cacheConfig.getAttributeNS(null, "maximumCachedElements")));
        }
    }

    if (pluginConfig.hasAttributeNS(null, "cacheResults")) {
        log.warn(
                "Data connection {}: use of 'cacheResults' attribute is deprecated.  Use <ResultCache> instead.",
                pluginId);
        cacheResults = XMLHelper
                .getAttributeValueAsBoolean(pluginConfig.getAttributeNodeNS(null, "cacheResults"));
    }

    if (cacheResults) {
        log.debug("Data connector {} is caching results: {}", pluginId, cacheResults);

        pluginBuilder.addPropertyReference("cacheManager", cacheManagerId);

        log.debug("Data connector {} cache element time to live: {}ms", pluginId, cacheElementTtl);
        pluginBuilder.addPropertyValue("cacheElementTimeToLive", cacheElementTtl);

        log.debug("Data connector {} maximum number of caches elements: {}", pluginId, maximumCachedElements);
        pluginBuilder.addPropertyValue("maximumCachedElements", maximumCachedElements);
    }

}

From source file:edu.internet2.middleware.shibboleth.common.config.attribute.resolver.dataConnector.LdapDataConnectorBeanDefinitionParser.java

/**
 * Process the basic LDAP connection configuration for the LDAP data connector.
 * /*from  w w w .  j a va2 s .  co  m*/
 * @param pluginId ID of the LDAP plugin
 * @param pluginConfig LDAP plugin configuration element
 * @param pluginConfigChildren child elements of the plugin
 * @param pluginBuilder plugin builder
 * @param parserContext current parsing context
 */
protected void processBasicConnectionConfig(String pluginId, Element pluginConfig,
        Map<QName, List<Element>> pluginConfigChildren, BeanDefinitionBuilder pluginBuilder,
        ParserContext parserContext) {

    String ldapURL = pluginConfig.getAttributeNS(null, "ldapURL");
    log.debug("Data connector {} LDAP URL: {}", pluginId, ldapURL);
    pluginBuilder.addPropertyValue("ldapUrl", ldapURL);

    ConnectionStrategy connStrategy = ConnectionStrategy.ACTIVE_PASSIVE;
    if (pluginConfig.hasAttributeNS(null, "connectionStrategy")) {
        connStrategy = ConnectionStrategy.valueOf(pluginConfig.getAttributeNS(null, "connectionStrategy"));
    }
    log.debug("Data connector {} connection strategy: {}", pluginId, connStrategy);
    pluginBuilder.addPropertyValue("connectionStrategy", connStrategy);

    if (pluginConfig.hasAttributeNS(null, "baseDN")) {
        String baseDN = pluginConfig.getAttributeNS(null, "baseDN");
        log.debug("Data connector {} base DN: {}", pluginId, baseDN);
        pluginBuilder.addPropertyValue("baseDN", baseDN);
    }

    AUTHENTICATION_TYPE authnType = AUTHENTICATION_TYPE.SIMPLE;
    if (pluginConfig.hasAttributeNS(null, "authenticationType")) {
        authnType = AUTHENTICATION_TYPE.valueOf(pluginConfig.getAttributeNS(null, "authenticationType"));
    }
    log.debug("Data connector {} authentication type: {}", pluginId, authnType);
    pluginBuilder.addPropertyValue("authenticationType", authnType);

    String principal = pluginConfig.getAttributeNS(null, "principal");
    log.debug("Data connector {} principal: {}", pluginId, principal);
    pluginBuilder.addPropertyValue("principal", principal);

    String credential = pluginConfig.getAttributeNS(null, "principalCredential");
    pluginBuilder.addPropertyValue("principalCredential", credential);

    String templateEngineRef = pluginConfig.getAttributeNS(null, "templateEngine");
    pluginBuilder.addPropertyReference("templateEngine", templateEngineRef);

    String filterTemplate = pluginConfigChildren
            .get(new QName(DataConnectorNamespaceHandler.NAMESPACE, "FilterTemplate")).get(0).getTextContent();
    filterTemplate = DatatypeHelper.safeTrimOrNullString(filterTemplate);
    log.debug("Data connector {} LDAP filter template: {}", pluginId, filterTemplate);
    pluginBuilder.addPropertyValue("filterTemplate", filterTemplate);

    SearchScope searchScope = SearchScope.SUBTREE;
    if (pluginConfig.hasAttributeNS(null, "searchScope")) {
        searchScope = SearchScope.valueOf(pluginConfig.getAttributeNS(null, "searchScope"));
    }
    log.debug("Data connector {} search scope: {}", pluginId, searchScope);
    pluginBuilder.addPropertyValue("searchScope", searchScope);

    QName returnAttributesName = new QName(DataConnectorNamespaceHandler.NAMESPACE, "ReturnAttributes");
    if (pluginConfigChildren.containsKey(returnAttributesName)) {
        List<String> returnAttributes = XMLHelper
                .getElementContentAsList(pluginConfigChildren.get(returnAttributesName).get(0));
        log.debug("Data connector {} return attributes: {}", pluginId, returnAttributes);
        pluginBuilder.addPropertyValue("returnAttributes", returnAttributes);
    }
}

From source file:org.unitedid.shibboleth.config.attribute.resolver.dataConnector.MongoDbDataConnectorBeanDefinitionParser.java

/** {@inheritDoc} */
protected void doParse(String pluginId, Element pluginConfig, Map<QName, List<Element>> pluginConfigChildren,
        BeanDefinitionBuilder pluginBuilder, ParserContext parserContext) {
    super.doParse(pluginId, pluginConfig, pluginConfigChildren, pluginBuilder, parserContext);

    /**/*  w  ww. j a v  a  2 s .c  o m*/
     * Data connector attributes (<resolver:DataConnector attr1="" attr2=""></resolver:DataConnector>)
     */
    String mongoDbName = pluginConfig.getAttributeNS(null, "mongoDbName");
    log.info("Data connector {} MONGODB DATABASE: {}", pluginId, mongoDbName);
    pluginBuilder.addPropertyValue("mongoDbName", mongoDbName);

    String mongoCollection = pluginConfig.getAttributeNS(null, "mongoCollection");
    log.info("Data connector {} MONGODB COLLECTION: {}", pluginId, mongoCollection);
    pluginBuilder.addPropertyValue("mongoCollection", mongoCollection);

    if (pluginConfig.hasAttributeNS(null, "mongoUser")) {
        String mongoUser = pluginConfig.getAttributeNS(null, "mongoUser");
        log.info("Data connector {} MONGODB USERNAME: {}", pluginId, mongoUser);
        pluginBuilder.addPropertyValue("mongoUser", mongoUser);
    }

    if (pluginConfig.hasAttributeNS(null, "mongoPassword")) {
        String mongoPassword = pluginConfig.getAttributeNS(null, "mongoPassword");
        pluginBuilder.addPropertyValue("mongoPassword", mongoPassword);
    }

    String preferredRead = "primaryPreferred";
    if (pluginConfig.hasAttributeNS(null, "preferredRead")) {
        preferredRead = pluginConfig.getAttributeNS(null, "preferredRead");
    }
    log.info("Data connector {} preferredRead type: {}", pluginId, preferredRead);
    pluginBuilder.addPropertyValue("preferredRead", preferredRead);

    boolean cacheResults = false;
    if (pluginConfig.hasAttributeNS(null, "cacheResults")) {
        cacheResults = XMLHelper
                .getAttributeValueAsBoolean(pluginConfig.getAttributeNodeNS(null, "cacheResults"));
    }
    log.info("Data connector {} cache results: {}", pluginId, cacheResults);
    pluginBuilder.addPropertyValue("cacheResults", cacheResults);

    /**
     * Mongodb host entries (<uid:MongoHost host="" port="" />)
     */
    List<ServerAddress> hosts = parseMongoHostNames(pluginId, pluginConfigChildren);
    log.debug("Data connector {} hosts {}", pluginId, hosts.toString());
    pluginBuilder.addPropertyValue("mongoHost", hosts);

    boolean usePersistentId = false;
    if (pluginConfigChildren.containsKey(PID_ELEMENT_NAME)) {
        Element e = pluginConfigChildren.get(PID_ELEMENT_NAME).get(0);
        pluginBuilder.addPropertyValue("pidGeneratedAttributeId",
                e.getAttributeNS(null, "generatedAttributeId"));
        pluginBuilder.addPropertyValue("pidSourceAttributeId", e.getAttributeNS(null, "sourceAttributeId"));
        usePersistentId = true;
    }
    log.info("Data connector {} running in persistentId mode: {}", pluginId, usePersistentId);
    pluginBuilder.addPropertyValue("usePersistentId", usePersistentId);

    List<MongoDbKeyAttributeMapper> keyAttributeMaps = parseAttributeMappings(pluginId, pluginConfigChildren);
    pluginBuilder.addPropertyValue("keyAttributeMap", keyAttributeMaps);

    if (!usePersistentId) {
        String queryTemplate = pluginConfigChildren.get(QUERY_TEMPLATE_ELEMENT_NAME).get(0).getTextContent();
        queryTemplate = DatatypeHelper.safeTrimOrNullString(queryTemplate);
        log.debug("Data connector {} query template: {}", pluginId, queryTemplate);
        pluginBuilder.addPropertyValue("queryTemplate", queryTemplate);
    }

    String templateEngineRef = pluginConfig.getAttributeNS(null, "templateEngine");
    pluginBuilder.addPropertyReference("templateEngine", templateEngineRef);
}

From source file:org.drools.container.spring.namespace.KnowledgeBaseDefinitionParser.java

@SuppressWarnings("unchecked")
@Override//from   www.  j a  va 2s.c om
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(KnowledgeBaseBeanFactory.class);

    Element kbaseConf = DomUtils.getChildElementByTagName(element, "configuration");
    if (kbaseConf != null) {
        BeanDefinitionBuilder rbaseConfBuilder = BeanDefinitionBuilder
                .rootBeanDefinition(RuleBaseConfiguration.class);
        Element e = DomUtils.getChildElementByTagName(kbaseConf, ADVANCED_PROCESS_RULE_INTEGRATED);
        if (e != null && !StringUtils.isEmpty(e.getAttribute("enabled"))) {
            rbaseConfBuilder.addPropertyValue("advancedProcessRuleIntegration",
                    Boolean.parseBoolean(e.getAttribute("enabled")));
        }

        e = DomUtils.getChildElementByTagName(kbaseConf, MULTITHREADS);
        if (e != null && !StringUtils.isEmpty(e.getAttribute("enabled"))) {
            rbaseConfBuilder.addPropertyValue("multithreadEvaluation",
                    Boolean.parseBoolean(e.getAttribute("enabled")));
            if (!StringUtils.isEmpty(e.getAttribute(MAX_THREADS))) {
                rbaseConfBuilder.addPropertyValue("maxThreads", Integer.parseInt(e.getAttribute(MAX_THREADS)));
            }
        }

        e = DomUtils.getChildElementByTagName(kbaseConf, MBEABS);
        if (e != null && !StringUtils.isEmpty(e.getAttribute("enabled"))) {
            rbaseConfBuilder.addPropertyValue("MBeansEnabled", Boolean.parseBoolean(e.getAttribute("enabled")));
        }

        e = DomUtils.getChildElementByTagName(kbaseConf, EVENT_PROCESSING_MODE);
        if (e != null && !StringUtils.isEmpty(e.getAttribute("mode"))) {
            rbaseConfBuilder.addPropertyValue("eventProcessingMode",
                    EventProcessingOption.valueOf(e.getAttribute("mode")));
        }

        e = DomUtils.getChildElementByTagName(kbaseConf, ASSERT_BEHAVIOR);
        if (e != null && !StringUtils.isEmpty(e.getAttribute("mode"))) {
            rbaseConfBuilder.addPropertyValue("assertBehaviour",
                    AssertBehaviour.determineAssertBehaviour(e.getAttribute("mode")));
        }

        e = DomUtils.getChildElementByTagName(kbaseConf, ACCUMULATE_FUNCTIONS);
        if (e != null) {
            List<Element> children = DomUtils.getChildElementsByTagName(e, ACCUMULATE_FUNCTION);
            if (children != null && !children.isEmpty()) {
                ManagedMap functions = new ManagedMap();
                for (Element child : children) {
                    functions.put(child.getAttribute("name"),
                            new RuntimeBeanReference(child.getAttribute("ref")));
                }
                factory.addPropertyValue("accumulateFunctions", functions);
            }
        }

        e = DomUtils.getChildElementByTagName(kbaseConf, EVALUATORS);
        if (e != null) {
            List<Element> children = DomUtils.getChildElementsByTagName(e, EVALUATOR);
            if (children != null && !children.isEmpty()) {
                ManagedMap evaluators = new ManagedMap();
                for (Element child : children) {
                    evaluators.put(child.getAttribute("name"),
                            new RuntimeBeanReference(child.getAttribute("ref")));
                }
                factory.addPropertyValue("evaluators", evaluators);
            }
        }

        e = DomUtils.getChildElementByTagName(kbaseConf, CONSEQUENCE_EXCEPTION_HANDLER);
        if (e != null && !StringUtils.isEmpty(e.getAttribute("handler"))) {
            rbaseConfBuilder.addPropertyValue("consequenceExceptionHandler", e.getAttribute("handler"));
        }

        factory.addPropertyValue("conf", rbaseConfBuilder.getBeanDefinition());
    }

    String nodeRef = element.getAttribute(EXECUTION_NODE_ATTRIBUTE);
    if (nodeRef != null && nodeRef.length() > 0) {
        factory.addPropertyReference(EXECUTION_NODE_ATTRIBUTE, nodeRef);
    }

    ManagedList resources = getResources(element, parserContext, factory);

    if (resources != null) {
        factory.addPropertyValue("resources", resources);
    }

    return factory.getBeanDefinition();
}

From source file:nl.surfnet.spring.security.opensaml.config.ServiceProviderBeanDefinitionParser.java

@Override
protected AbstractBeanDefinition parseInternal(final Element element, final ParserContext parserContext) {

    final String preAuthFilterRef = element.getAttribute("preauth-filter-ref");
    if (StringUtils.isBlank(preAuthFilterRef)) {
        parserContext.getReaderContext().error("The preauth-filter-ref is mandatory", element);
    }//from   w  w w. j  a  v a 2 s  . co  m

    final String messageHandlerRef = element.getAttribute("message-handler-ref");
    if (StringUtils.isBlank(messageHandlerRef)) {
        parserContext.getReaderContext().error("The message-handler-ref is mandatory", element);
    }

    final String certificatestoreRef = element.getAttribute("certificatestore-ref");
    if (StringUtils.isBlank(certificatestoreRef)) {
        parserContext.getReaderContext().error("The certificatestore-ref is mandatory", element);
    }

    final String provisionerRef = element.getAttribute("provisioner-ref");
    if (StringUtils.isBlank(provisionerRef)) {
        parserContext.getReaderContext().error("The provisioner-ref is mandatory", element);
    }

    final String authenticationManangerRef = element.getAttribute("authentication-manager-ref");
    if (StringUtils.isBlank(authenticationManangerRef)) {
        parserContext.getReaderContext().error("The authentication-manager-ref is mandatory", element);
    }

    final String entityID = element.getAttribute("entity-id");
    if (StringUtils.isBlank(entityID)) {
        parserContext.getReaderContext().error("The entity-id is mandatory", element);
    }

    final String assertionConsumerURI = element.getAttribute("assertion-consumer-uri");
    if (StringUtils.isBlank(assertionConsumerURI)) {
        parserContext.getReaderContext().error("Missing or empty assertion-consumer-uri.", element);
    }

    final String poolSize = element.getAttribute("max-parser-pool-size");
    try {
        poolSizeInt = Integer.parseInt(poolSize);
    } catch (NumberFormatException nfe) {
        parserContext.getReaderContext().error("An invalid value for max-parser-pool-size was supplied",
                element);
    }

    final String replayCacheLife = element.getAttribute("replay-cache-life-in-millis");
    try {
        replayCacheDuration = Integer.parseInt(replayCacheLife);
    } catch (NumberFormatException nfe) {
        parserContext.getReaderContext().error("An invalid value for replay-cache-life-in-millis was supplied",
                element);
    }

    final String clockSkew = element.getAttribute("issue-instant-check-clock-skew-in-secs");
    try {
        newClockSkew = Integer.parseInt(clockSkew);
    } catch (NumberFormatException nfe) {
        parserContext.getReaderContext()
                .error("An invalid value for issue-instant-check-clock-skew-in-secs was supplied", element);
    }

    final String validTime = element.getAttribute("issue-instant-check-valid-time-in-secs");
    try {
        newExpires = Integer.parseInt(validTime);
    } catch (NumberFormatException nfe) {
        parserContext.getReaderContext()
                .error("An invalid value for issue-instant-check-valid-time-in-secs was supplied", element);
    }

    BeanDefinitionBuilder bootstrapBean = BeanDefinitionBuilder.genericBeanDefinition(DefaultBootstrap.class);
    bootstrapBean.setInitMethodName("bootstrap");
    parserContext.getRegistry().registerBeanDefinition(BEAN_SAMLINITIALIZER, bootstrapBean.getBeanDefinition());

    final BasicParserPool basicParserPool = new BasicParserPool();
    basicParserPool.setMaxPoolSize(poolSizeInt);

    final HTTPPostSimpleSignDecoder httpPostSimpleSignDecoder = new HTTPPostSimpleSignDecoder(basicParserPool);

    final VelocityEngineFactoryBean velocityEngineFactoryBean = new VelocityEngineFactoryBean();
    velocityEngineFactoryBean.setPreferFileSystemAccess(false);
    Properties velocityEngineProperties = new Properties();
    velocityEngineProperties.setProperty("resource.loader", "classpath");
    velocityEngineProperties.setProperty("classpath.resource.loader.class",
            "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
    velocityEngineFactoryBean.setVelocityProperties(velocityEngineProperties);
    VelocityEngine velocityEngine = null;
    try {
        velocityEngine = velocityEngineFactoryBean.createVelocityEngine();
    } catch (IOException e) {
        throw new RuntimeException("Unable to create velocity engine instance");
    }

    // Replay cache
    BeanDefinitionBuilder replayCacheBuilder = BeanDefinitionBuilder.genericBeanDefinition(ReplayCache.class);
    replayCacheBuilder.addConstructorArgValue(new MapBasedStorageService());
    replayCacheBuilder.addConstructorArgValue(replayCacheDuration);
    parserContext.getRegistry().registerBeanDefinition(BEAN_REPLAYCACHE,
            replayCacheBuilder.getBeanDefinition());

    // Message replay rule
    BeanDefinitionBuilder messageReplayRuleBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(MessageReplayRule.class);
    messageReplayRuleBuilder.addConstructorArgReference(BEAN_REPLAYCACHE);
    parserContext.getRegistry().registerBeanDefinition("messageReplayRule",
            messageReplayRuleBuilder.getBeanDefinition());

    // Issue instant rule
    BeanDefinitionBuilder issueInstantBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(IssueInstantRule.class);
    issueInstantBuilder.addConstructorArgValue(newClockSkew);
    issueInstantBuilder.addConstructorArgValue(newExpires);
    parserContext.getRegistry().registerBeanDefinition("issueInstantRule",
            issueInstantBuilder.getBeanDefinition());

    // KeyStore Credential Resolver
    BeanDefinitionBuilder keyStoreBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(KeyStoreCredentialResolverDelegate.class);
    keyStoreBuilder.addPropertyReference("keyStore", certificatestoreRef);
    parserContext.getRegistry().registerBeanDefinition(BEAN_KEYSTORECREDENTIALRESOLVER,
            keyStoreBuilder.getBeanDefinition());

    // Signature Rule Builder
    BeanDefinitionBuilder signatureRuleBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(SignatureSecurityPolicyRule.class);
    signatureRuleBuilder.addConstructorArgValue(new SAMLSignatureProfileValidator());
    signatureRuleBuilder.addPropertyReference("credentialResolver", BEAN_KEYSTORECREDENTIALRESOLVER);

    // List of rule beans
    final ManagedList<BeanMetadataElement> beanMetadataElements = new ManagedList<BeanMetadataElement>();
    beanMetadataElements.add(signatureRuleBuilder.getBeanDefinition());
    beanMetadataElements.add(issueInstantBuilder.getBeanDefinition());
    beanMetadataElements.add(messageReplayRuleBuilder.getBeanDefinition());

    // Security Policy
    BeanDefinitionBuilder securityPolicyDelegateBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(SecurityPolicyDelegate.class);
    securityPolicyDelegateBuilder.addConstructorArgValue(beanMetadataElements);
    parserContext.getRegistry().registerBeanDefinition(BEAN_SECURITYPOLICY,
            securityPolicyDelegateBuilder.getBeanDefinition());

    // Security Policy Resolver
    BeanDefinitionBuilder securityPolicyResolverBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(StaticSecurityPolicyResolver.class);
    securityPolicyResolverBuilder.addConstructorArgReference(BEAN_SECURITYPOLICY);
    parserContext.getRegistry().registerBeanDefinition(BEAN_SECURITYPOLICYRESOLVER,
            securityPolicyResolverBuilder.getBeanDefinition());

    // Message Handler
    BeanDefinitionBuilder postBindingAdapter = BeanDefinitionBuilder
            .rootBeanDefinition(SAMLMessageHandlerImpl.class);
    postBindingAdapter.addConstructorArgValue(httpPostSimpleSignDecoder);
    postBindingAdapter.addConstructorArgReference(BEAN_SECURITYPOLICYRESOLVER);
    postBindingAdapter.addPropertyValue("velocityEngine", velocityEngine);
    postBindingAdapter.addPropertyValue("entityId", entityID);
    parserContext.getRegistry().registerBeanDefinition(messageHandlerRef,
            postBindingAdapter.getBeanDefinition());

    // Assertion Consumer Bean
    BeanDefinitionBuilder assertionComsumerBean = BeanDefinitionBuilder
            .genericBeanDefinition(AssertionConsumerImpl.class);
    assertionComsumerBean.addPropertyReference("provisioner", provisionerRef);
    parserContext.getRegistry().registerBeanDefinition(BEAN_ASSERTIONCONSUMER,
            assertionComsumerBean.getBeanDefinition());

    BeanDefinitionBuilder authenticationProvider = BeanDefinitionBuilder
            .rootBeanDefinition(SAMLResponseAuthenticationProvider.class);
    authenticationProvider.addConstructorArgReference(BEAN_ASSERTIONCONSUMER);
    parserContext.getRegistry().registerBeanDefinition(BEAN_AUTHENTICATIONPROVIDER,
            authenticationProvider.getBeanDefinition());

    // Pre Auth Filter
    final HttpSessionRequestCache requestCache = new HttpSessionRequestCache();
    final AuthenticationFailureHandlerImpl authenticationFailureHandler = new AuthenticationFailureHandlerImpl(
            requestCache);

    // Authentication Filter
    BeanDefinitionBuilder authenticationFilter = BeanDefinitionBuilder
            .rootBeanDefinition(SAMLResponseAuthenticationProcessingFilter.class);
    authenticationFilter.addConstructorArgValue(assertionConsumerURI);
    authenticationFilter.addPropertyReference("SAMLMessageHandler", messageHandlerRef);
    authenticationFilter.addPropertyReference("authenticationManager", authenticationManangerRef);
    authenticationFilter.addPropertyValue("authenticationFailureHandler", authenticationFailureHandler);
    parserContext.getRegistry().registerBeanDefinition(preAuthFilterRef,
            authenticationFilter.getBeanDefinition());

    return authenticationProvider.getBeanDefinition();
}

From source file:org.apache.camel.spring.handler.CamelNamespaceHandler.java

protected void createBeanPostProcessor(ParserContext parserContext, String contextId, Element childElement,
        BeanDefinitionBuilder parentBuilder) {
    String beanPostProcessorId = contextId + ":beanPostProcessor";
    childElement.setAttribute("id", beanPostProcessorId);
    BeanDefinition definition = beanPostProcessorParser.parse(childElement, parserContext);
    // only register to camel context id as a String. Then we can look it up later
    // otherwise we get a circular reference in spring and it will not allow custom bean post processing
    // see more at CAMEL-1663
    definition.getPropertyValues().addPropertyValue("camelId", contextId);
    parentBuilder.addPropertyReference("beanPostProcessor", beanPostProcessorId);
}