renamed modules org.springframework.integration.* -> spring-integration-*

@Ignore'd SimpleTcpNetOutboundGatewayTests#testOutboundClose() to avoid failure; this failure is correlated to the module name change, but hard to understand how it would be caused by it

spring-integration-security/src/main/java/org/springframework/integration/security/channel/ChannelAccessPolicy.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2002-2008 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.integration.security.channel;
+
+import org.springframework.security.ConfigAttributeDefinition;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+/**
+ * Creates the {@link ConfigAttributeDefinition}s for secured channel
+ * send and receive operations based on simple String values.
+ * 
+ * @author Mark Fisher
+ */
+public class ChannelAccessPolicy {
+
+	private final ConfigAttributeDefinition configAttributeDefinitionForSend;
+
+	private final ConfigAttributeDefinition configAttributeDefinitionForReceive;
+
+
+	/**
+	 * Create an access policy instance. The provided 'sendAccess' and 'receiveAccess'
+	 * values may be a single String or a comma-delimited list of values. All whitespace
+	 * will be trimmed. A <code>null</code> value indicates that the policy does not
+	 * apply for either send or receive access type. At most one of the values may be null. 
+	 */
+	public ChannelAccessPolicy(String sendAccess, String receiveAccess) {
+		Assert.isTrue(sendAccess != null || receiveAccess != null,
+				"At least one of 'sendAccess' and 'receiveAccess' must not be null.");
+		String[] sendValues = StringUtils.trimArrayElements(
+				StringUtils.commaDelimitedListToStringArray(sendAccess));
+		String[] receiveValues = StringUtils.trimArrayElements(
+				StringUtils.commaDelimitedListToStringArray(receiveAccess));
+		this.configAttributeDefinitionForSend = (sendValues.length > 0)
+				? new ConfigAttributeDefinition(sendValues) : null;
+		this.configAttributeDefinitionForReceive = (receiveValues.length > 0)
+				? new ConfigAttributeDefinition(receiveValues) : null;
+	}
+
+
+	public ConfigAttributeDefinition getConfigAttributeDefinitionForSend() {
+		return this.configAttributeDefinitionForSend;
+	}
+
+	public ConfigAttributeDefinition getConfigAttributeDefinitionForReceive() {
+		return this.configAttributeDefinitionForReceive;
+	}
+
+}

spring-integration-security/src/main/java/org/springframework/integration/security/channel/ChannelInvocation.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2002-2008 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.integration.security.channel;
+
+import org.aopalliance.intercept.MethodInvocation;
+
+import org.springframework.integration.core.Message;
+import org.springframework.integration.core.MessageChannel;
+import org.springframework.util.Assert;
+
+/**
+ * Secured object for {@link ChannelSecurityInterceptor}. Maintains a reference
+ * to the original {@link MethodInvocation} instance and provides convenient
+ * access to the secured {@link MessageChannel}. If the intercepted invocation
+ * is a <em>send</em> operation, the {@link Message} is also available.
+ * 
+ * @author Mark Fisher
+ */
+public class ChannelInvocation {
+
+	private final MessageChannel channel;
+
+	private final Message<?> message;
+
+	private final MethodInvocation methodInvocation;
+
+
+	/**
+	 * @param methodInvocation the intercepted MethodInvocation instance
+	 */
+	public ChannelInvocation(MethodInvocation methodInvocation) {
+		Assert.notNull(methodInvocation, "MethodInvocation must not be null");
+		Assert.isAssignable(MessageChannel.class, methodInvocation.getThis().getClass(),
+				"MethodInvocation must be on a MessageChannel");
+		this.channel = (MessageChannel) methodInvocation.getThis();
+		if (methodInvocation.getMethod().getName().equals("send")) {
+			if (methodInvocation.getArguments().length < 1 || !(methodInvocation.getArguments()[0] instanceof Message)) {
+				throw new IllegalStateException("expected a Message as the first parameter of the channel's send method");
+			}
+			this.message = (Message<?>) methodInvocation.getArguments()[0];
+		}
+		else {
+			this.message = null;
+		}
+		this.methodInvocation = methodInvocation;
+	}
+
+
+	public MessageChannel getChannel() {
+		return this.channel;
+	}
+
+	public Message<?> getMessage() {
+		return this.message;
+	}
+
+	public MethodInvocation getMethodInvocation() {
+		return this.methodInvocation;
+	}
+
+	public boolean isSend() {
+		return "send".equals(this.methodInvocation.getMethod().getName());
+	}
+
+	public boolean isReceive() {
+		return "receive".equals(this.methodInvocation.getMethod().getName());
+	}
+
+}

spring-integration-security/src/main/java/org/springframework/integration/security/channel/ChannelInvocationDefinitionSource.java

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.integration.security.channel;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import org.springframework.integration.context.NamedComponent;
+import org.springframework.integration.core.MessageChannel;
+import org.springframework.security.ConfigAttribute;
+import org.springframework.security.ConfigAttributeDefinition;
+import org.springframework.security.intercept.ObjectDefinitionSource;
+import org.springframework.util.Assert;
+
+/**
+ * The {@link ObjectDefinitionSource} implementation for secured {@link MessageChannel}s.
+ * 
+ * @author Mark Fisher
+ */
+public class ChannelInvocationDefinitionSource implements ObjectDefinitionSource {
+
+	private final Map<Pattern, ChannelAccessPolicy> patternMappings;
+
+
+	public ChannelInvocationDefinitionSource() {
+		this(null);
+	}
+
+	public ChannelInvocationDefinitionSource(Map<Pattern, ChannelAccessPolicy> patternMappings) {
+		this.patternMappings = (patternMappings != null) ? patternMappings
+				: new LinkedHashMap<Pattern, ChannelAccessPolicy>();
+	}
+
+
+	public void addPatternMapping(Pattern pattern, ChannelAccessPolicy accessPolicy) {
+		this.patternMappings.put(pattern, accessPolicy);
+	}
+
+	public Set<Pattern> getPatterns() {
+		return this.patternMappings.keySet();
+	}
+
+	@SuppressWarnings("unchecked")
+	public boolean supports(Class clazz) {
+		return ChannelInvocation.class.isAssignableFrom(clazz);
+	}
+
+	@SuppressWarnings("unchecked")
+	public ConfigAttributeDefinition getAttributes(Object object) throws IllegalArgumentException {
+		Assert.isAssignable(ChannelInvocation.class, object.getClass());
+		ChannelInvocation invocation = (ChannelInvocation) object;
+		MessageChannel channel = invocation.getChannel();
+		Assert.isAssignable(NamedComponent.class, channel.getClass());
+		String channelName = ((NamedComponent) channel).getComponentName();
+		List<ConfigAttribute> attributes = new ArrayList<ConfigAttribute>();
+		for (Map.Entry<Pattern, ChannelAccessPolicy> mapping : this.patternMappings.entrySet()) {
+			Pattern pattern = mapping.getKey();
+			ChannelAccessPolicy accessPolicy = mapping.getValue();
+			if (pattern.matcher(channelName).matches()) {
+				if (invocation.isSend()) {
+					ConfigAttributeDefinition definition = accessPolicy.getConfigAttributeDefinitionForSend();
+					if (definition != null) {
+						attributes.addAll(definition.getConfigAttributes());
+					}
+				}
+				else if (invocation.isReceive()) {
+					ConfigAttributeDefinition definition = accessPolicy.getConfigAttributeDefinitionForReceive();
+					if (definition != null) {
+						attributes.addAll(definition.getConfigAttributes());
+					}
+				}
+			}
+		}
+		return new ConfigAttributeDefinition(attributes);
+	}
+
+	public Collection<?> getConfigAttributeDefinitions() {
+		Set<ConfigAttributeDefinition> definitions = new HashSet<ConfigAttributeDefinition>();
+		for (ChannelAccessPolicy accessPolicy : this.patternMappings.values()) {
+			ConfigAttributeDefinition sendDefinition = accessPolicy.getConfigAttributeDefinitionForSend();
+			if (sendDefinition != null) {
+				definitions.add(sendDefinition);
+			}
+			ConfigAttributeDefinition receiveDefinition = accessPolicy.getConfigAttributeDefinitionForReceive();
+			if (receiveDefinition != null) {
+				definitions.add(receiveDefinition);
+			}
+		}
+		return definitions;
+	}
+
+}

spring-integration-security/src/main/java/org/springframework/integration/security/channel/ChannelSecurityInterceptor.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2002-2008 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.integration.security.channel;
+
+import java.lang.reflect.Method;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+
+import org.springframework.security.intercept.AbstractSecurityInterceptor;
+import org.springframework.security.intercept.InterceptorStatusToken;
+import org.springframework.security.intercept.ObjectDefinitionSource;
+import org.springframework.util.Assert;
+
+/**
+ * An AOP interceptor that enforces authorization for MessageChannel send and/or receive calls.
+ * 
+ * @author Mark Fisher
+ */
+public class ChannelSecurityInterceptor extends AbstractSecurityInterceptor implements MethodInterceptor {
+
+	private final ChannelInvocationDefinitionSource objectDefinitionSource;
+
+
+	public ChannelSecurityInterceptor(ChannelInvocationDefinitionSource objectDefinitionSource) {
+		Assert.notNull(objectDefinitionSource, "objectDefinitionSource must not be null");
+		this.objectDefinitionSource = objectDefinitionSource;
+	}
+
+
+	@Override
+	public Class<?> getSecureObjectClass() {
+		return ChannelInvocation.class;
+	}
+
+	@Override
+	public ObjectDefinitionSource obtainObjectDefinitionSource() {
+		return this.objectDefinitionSource;
+	}
+
+	public Object invoke(MethodInvocation invocation) throws Throwable {
+		Method method = invocation.getMethod();
+		if (method.getName().equals("send") || method.getName().equals("receive")) {
+			return this.invokeWithAuthorizationCheck(invocation);
+		}
+		return invocation.proceed();
+	}
+
+	private Object invokeWithAuthorizationCheck(MethodInvocation methodInvocation) throws Throwable {
+		Object returnValue = null;
+		InterceptorStatusToken token = super.beforeInvocation(new ChannelInvocation(methodInvocation));
+		try {
+			returnValue = methodInvocation.proceed();
+		}
+		finally {
+			returnValue = super.afterInvocation(token, returnValue);
+		}
+		return returnValue;
+	}
+
+}

spring-integration-security/src/main/java/org/springframework/integration/security/config/ChannelSecurityInterceptorBeanPostProcessor.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.integration.security.config;
+
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import org.springframework.aop.framework.ProxyFactory;
+import org.springframework.aop.support.DefaultPointcutAdvisor;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.integration.core.MessageChannel;
+import org.springframework.integration.security.channel.ChannelInvocationDefinitionSource;
+import org.springframework.integration.security.channel.ChannelSecurityInterceptor;
+import org.springframework.util.Assert;
+
+/**
+ * A {@link BeanPostProcessor} that proxies {@link MessageChannel}s to apply a {@link ChannelSecurityInterceptor}.
+ * 
+ * @author Mark Fisher
+ */
+public class ChannelSecurityInterceptorBeanPostProcessor implements BeanPostProcessor {
+
+	private final ChannelSecurityInterceptor interceptor;
+
+
+	public ChannelSecurityInterceptorBeanPostProcessor(ChannelSecurityInterceptor interceptor) {
+		Assert.notNull(interceptor, "interceptor must not be null");
+		this.interceptor = interceptor;
+	}
+
+
+	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+		return bean;
+	}
+
+	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
+		if (bean instanceof MessageChannel && shouldProxy(beanName, (MessageChannel) bean,
+				(ChannelInvocationDefinitionSource) this.interceptor.obtainObjectDefinitionSource())) {
+			ProxyFactory proxyFactory = new ProxyFactory(bean);
+			proxyFactory.addAdvisor(new DefaultPointcutAdvisor(this.interceptor));
+			return proxyFactory.getProxy();
+		}
+		return bean;
+	}
+
+	private boolean shouldProxy(String beanName, MessageChannel channel, ChannelInvocationDefinitionSource definitionSource) {
+		Set<Pattern> patterns = ((ChannelInvocationDefinitionSource) this.interceptor.obtainObjectDefinitionSource()).getPatterns();
+		for (Pattern pattern : patterns) {
+			if (pattern.matcher(beanName).matches()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+}

spring-integration-security/src/main/java/org/springframework/integration/security/config/IntegrationSecurityNamespaceHandler.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2002-2009 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.integration.security.config;
+
+import org.springframework.integration.config.xml.AbstractIntegrationNamespaceHandler;
+
+/**
+ * Namespace handler for the security namespace.
+ * 
+ * @author Jonas Partner
+ */
+public class IntegrationSecurityNamespaceHandler extends AbstractIntegrationNamespaceHandler {
+
+	public void init() {
+		registerBeanDefinitionParser("secured-channels", new SecuredChannelsParser());
+	}
+
+}

spring-integration-security/src/main/java/org/springframework/integration/security/config/SecuredChannelsParser.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2002-2008 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.integration.security.config;
+
+import java.util.List;
+import java.util.regex.Pattern;
+
+import org.w3c.dom.Element;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
+import org.springframework.beans.factory.support.ManagedMap;
+import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.integration.config.xml.IntegrationNamespaceUtils;
+import org.springframework.util.StringUtils;
+import org.springframework.util.xml.DomUtils;
+
+/**
+ * Creates a {@link org.springframework.integration.security.channel.ChannelSecurityInterceptor}
+ * to control send and receive access, and creates a bean post-processor to apply the
+ * interceptor to {@link org.springframework.integration.core.MessageChannel}s
+ * whose names match the specified patterns.
+ * 
+ * @author Jonas Partner
+ * @author Mark Fisher
+ */
+public class SecuredChannelsParser extends AbstractSingleBeanDefinitionParser {
+
+	private final static String BASE_PACKAGE_NAME = "org.springframework.integration.security";
+
+
+	@Override
+	protected String getBeanClassName(Element element) {
+		return BASE_PACKAGE_NAME + ".config.ChannelSecurityInterceptorBeanPostProcessor";
+	}
+
+	@Override
+	protected boolean shouldGenerateId() {
+		return true;
+	}
+
+	@Override
+	protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
+		String objectDefinitionSourceBeanName = this.parseObjectDefinitionSource(element, parserContext);
+		BeanDefinitionBuilder interceptorBuilder = BeanDefinitionBuilder.genericBeanDefinition(
+				BASE_PACKAGE_NAME + ".channel.ChannelSecurityInterceptor");
+		interceptorBuilder.addConstructorArgReference(objectDefinitionSourceBeanName);
+		IntegrationNamespaceUtils.setReferenceIfAttributeDefined(interceptorBuilder, element, "authentication-manager");
+		IntegrationNamespaceUtils.setReferenceIfAttributeDefined(interceptorBuilder, element, "access-decision-manager");
+		String interceptorBeanName = BeanDefinitionReaderUtils.registerWithGeneratedName(
+				interceptorBuilder.getBeanDefinition(), parserContext.getRegistry());
+		builder.addConstructorArgReference(interceptorBeanName);
+	}
+
+	@SuppressWarnings("unchecked")
+	private String parseObjectDefinitionSource(Element element, ParserContext parserContext) {
+		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
+				BASE_PACKAGE_NAME + ".channel.ChannelInvocationDefinitionSource");
+		List<Element> accessPolicyElements = (List<Element>) DomUtils.getChildElementsByTagName(element, "access-policy");
+		ManagedMap patternMappings = new ManagedMap();
+		for (Element accessPolicyElement : accessPolicyElements) {
+			Pattern pattern = Pattern.compile(accessPolicyElement.getAttribute("pattern"));
+			String sendAccess = accessPolicyElement.getAttribute("send-access");
+			String receiveAccess = accessPolicyElement.getAttribute("receive-access");
+			if (!StringUtils.hasText(sendAccess) && !StringUtils.hasText(receiveAccess)) {
+				parserContext.getReaderContext().error(
+						"At least one of 'send-access' or 'receive-access' must be provided.", accessPolicyElement);
+			}
+			BeanDefinitionBuilder accessPolicyBuilder = BeanDefinitionBuilder.genericBeanDefinition(
+					BASE_PACKAGE_NAME + ".channel.ChannelAccessPolicy");
+			accessPolicyBuilder.addConstructorArgValue(sendAccess);
+			accessPolicyBuilder.addConstructorArgValue(receiveAccess);
+			accessPolicyBuilder.getBeanDefinition().setRole(BeanDefinition.ROLE_SUPPORT);
+			patternMappings.put(pattern, accessPolicyBuilder.getBeanDefinition());
+		}
+		builder.addConstructorArgValue(patternMappings);
+		builder.setRole(BeanDefinition.ROLE_SUPPORT);
+		return BeanDefinitionReaderUtils.registerWithGeneratedName(
+				builder.getBeanDefinition(), parserContext.getRegistry());
+	}
+
+}

spring-integration-security/src/main/resources/META-INF/spring.handlers

@@ -0,0 +1 @@
+http\://www.springframework.org/schema/integration/security=org.springframework.integration.security.config.IntegrationSecurityNamespaceHandler

spring-integration-security/src/main/resources/META-INF/spring.schemas

@@ -0,0 +1,3 @@
+http\://www.springframework.org/schema/integration/security/spring-integration-security-1.0.xsd=org/springframework/integration/security/config/spring-integration-security-1.0.xsd
+http\://www.springframework.org/schema/integration/security/spring-integration-security-2.0.xsd=org/springframework/integration/security/config/spring-integration-security-2.0.xsd
+http\://www.springframework.org/schema/integration/security/spring-integration-security.xsd=org/springframework/integration/security/config/spring-integration-security-2.0.xsd

spring-integration-security/src/main/resources/META-INF/spring.tooling

@@ -0,0 +1,4 @@
+# Tooling related information for the integration security namespace
+http\://www.springframework.org/schema/integration/security@name=integration security Namespace
+http\://www.springframework.org/schema/integration/security@prefix=int-security
+http\://www.springframework.org/schema/integration/security@icon=org/springframework/integration/security/config/spring-integration-security.gif

spring-integration-security/src/main/resources/org/springframework/integration/security/config/spring-integration-security-1.0.xsd

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="http://www.springframework.org/schema/integration/security"
+	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+	xmlns:beans="http://www.springframework.org/schema/beans"
+	xmlns:tool="http://www.springframework.org/schema/tool"
+	targetNamespace="http://www.springframework.org/schema/integration/security"
+	elementFormDefault="qualified" attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" />
+	<xsd:import namespace="http://www.springframework.org/schema/tool" />
+
+	<xsd:element name="secured-channels">
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>
+	Defines security requirements for one or more Message Channels.
+				</xsd:documentation>
+			</xsd:annotation>
+			<xsd:sequence>
+				<xsd:element name="access-policy" type="accessPolicyType" minOccurs="1" maxOccurs="unbounded"/>
+			</xsd:sequence>
+			<xsd:attribute name="authentication-manager" type="xsd:string" default="authenticationManager">
+				<xsd:annotation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.security.AuthenticationManager"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="access-decision-manager" type="xsd:string" default="accessDecisionManager">
+				<xsd:annotation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.security.AccessDecisionManager"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:complexType name="accessPolicyType">
+		<xsd:annotation>
+			<xsd:documentation>
+	Defines the security access policy for send and/or receive invocations based on a Message Channel name pattern.
+			</xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="pattern" type="xsd:string" use="required"/>
+		<xsd:attribute name="send-access" type="xsd:string"/>
+		<xsd:attribute name="receive-access" type="xsd:string"/>
+	</xsd:complexType>
+
+</xsd:schema>

spring-integration-security/src/main/resources/org/springframework/integration/security/config/spring-integration-security-2.0.xsd

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="http://www.springframework.org/schema/integration/security"
+	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+	xmlns:beans="http://www.springframework.org/schema/beans"
+	xmlns:tool="http://www.springframework.org/schema/tool"
+	targetNamespace="http://www.springframework.org/schema/integration/security"
+	elementFormDefault="qualified" attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" />
+	<xsd:import namespace="http://www.springframework.org/schema/tool" />
+
+	<xsd:element name="secured-channels">
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation>
+	Defines security requirements for one or more Message Channels.
+				</xsd:documentation>
+			</xsd:annotation>
+			<xsd:sequence>
+				<xsd:element name="access-policy" type="accessPolicyType" minOccurs="1" maxOccurs="unbounded"/>
+			</xsd:sequence>
+			<xsd:attribute name="authentication-manager" type="xsd:string" default="authenticationManager">
+				<xsd:annotation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.security.AuthenticationManager"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="access-decision-manager" type="xsd:string" default="accessDecisionManager">
+				<xsd:annotation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.security.AccessDecisionManager"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:complexType name="accessPolicyType">
+		<xsd:annotation>
+			<xsd:documentation>
+	Defines the security access policy for send and/or receive invocations based on a Message Channel name pattern.
+			</xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="pattern" type="xsd:string" use="required"/>
+		<xsd:attribute name="send-access" type="xsd:string"/>
+		<xsd:attribute name="receive-access" type="xsd:string"/>
+	</xsd:complexType>
+
+</xsd:schema>