From a40e527938d76ba71f211da7e327adb50384ba69 Mon Sep 17 00:00:00 2001 From: lresende Date: Wed, 11 Nov 2009 23:26:33 +0000 Subject: Moving 1.x tags git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@835157 13f79535-47bb-0310-9956-ffa450edef68 --- .../xml/SCADefinitionsDocumentProcessor.java | 165 +++++++++++++ .../definitions/xml/SCADefinitionsProcessor.java | 196 ++++++++++++++++ .../definitions/xml/SCADefinitionsResolver.java | 52 +++++ ...ca.contribution.processor.StAXArtifactProcessor | 19 ++ .../sca/definitions/MockPolicyProcessor.java | 74 ++++++ .../org/apache/tuscany/sca/definitions/Policy.java | 32 +++ .../sca/definitions/ReadDocumentTestCase.java | 204 +++++++++++++++++ .../tuscany/sca/definitions/test_definitions.xml | 254 +++++++++++++++++++++ 8 files changed, 996 insertions(+) create mode 100644 sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsDocumentProcessor.java create mode 100644 sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsProcessor.java create mode 100644 sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsResolver.java create mode 100644 sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor create mode 100644 sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/MockPolicyProcessor.java create mode 100644 sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/Policy.java create mode 100644 sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/ReadDocumentTestCase.java create mode 100644 sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/resources/org/apache/tuscany/sca/definitions/test_definitions.xml (limited to 'sca-java-1.x/tags/1.2.1/modules/definitions-xml/src') diff --git a/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsDocumentProcessor.java b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsDocumentProcessor.java new file mode 100644 index 0000000000..049b3d60ef --- /dev/null +++ b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsDocumentProcessor.java @@ -0,0 +1,165 @@ +/* + * 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. + */ + +package org.apache.tuscany.sca.definitions.xml; + +import java.io.IOException; +import java.io.InputStream; +import java.net.URI; +import java.net.URL; +import java.net.URLConnection; + +import javax.xml.namespace.QName; +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLStreamConstants; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; + +import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor; +import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint; +import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor; +import org.apache.tuscany.sca.contribution.resolver.ModelResolver; +import org.apache.tuscany.sca.contribution.service.ContributionReadException; +import org.apache.tuscany.sca.contribution.service.ContributionResolveException; +import org.apache.tuscany.sca.definitions.SCADefinitions; +import org.apache.tuscany.sca.definitions.impl.SCADefinitionsImpl; +import org.apache.tuscany.sca.definitions.util.SCADefinitionsUtil; +import org.apache.tuscany.sca.policy.DefaultIntentAttachPointTypeFactory; +import org.apache.tuscany.sca.policy.IntentAttachPointTypeFactory; +import org.apache.tuscany.sca.policy.PolicyFactory; +import org.apache.tuscany.sca.policy.xml.BindingTypeProcessor; +import org.apache.tuscany.sca.policy.xml.ImplementationTypeProcessor; +import org.apache.tuscany.sca.policy.xml.PolicySetProcessor; +import org.apache.tuscany.sca.policy.xml.ProfileIntentProcessor; +import org.apache.tuscany.sca.policy.xml.QualifiedIntentProcessor; +import org.apache.tuscany.sca.policy.xml.SimpleIntentProcessor; + +/** + * A SCA Definitions Document processor. + * + */ +public class SCADefinitionsDocumentProcessor implements URLArtifactProcessor { + private StAXArtifactProcessor extensionProcessor; + //private SCADefinitionsBuilder definitionsBuilder; + private ModelResolver scaDefinitionsResolver; + private XMLInputFactory inputFactory; + private static final String TUSCANY_NS = "http://tuscany.apache.org/xmlns/sca/1.0"; + private static final String DEFINITIONS = "definitions"; + private static final QName tuscanyDefinitions = new QName(TUSCANY_NS,DEFINITIONS); + + /** + * Construct a new SCADefinitions processor + * @param assemblyFactory + * @param policyFactory + * @param staxProcessor + */ + public SCADefinitionsDocumentProcessor(StAXArtifactProcessorExtensionPoint staxProcessors, + StAXArtifactProcessor staxProcessor, + XMLInputFactory inputFactory, + PolicyFactory policyFactory) { + this.extensionProcessor = (StAXArtifactProcessor)staxProcessor; + this.inputFactory = inputFactory; + //definitionsBuilder = new SCADefinitionsBuilderImpl(); + this.scaDefinitionsResolver = new SCADefinitionsResolver(); + + IntentAttachPointTypeFactory intentAttachPointFactory = new DefaultIntentAttachPointTypeFactory(); + + SCADefinitionsProcessor scaDefnProcessor = new SCADefinitionsProcessor(policyFactory, extensionProcessor, scaDefinitionsResolver); + staxProcessors.addArtifactProcessor(scaDefnProcessor); + + staxProcessors.addArtifactProcessor(new SimpleIntentProcessor(policyFactory, extensionProcessor)); + staxProcessors.addArtifactProcessor(new ProfileIntentProcessor(policyFactory, extensionProcessor)); + staxProcessors.addArtifactProcessor(new QualifiedIntentProcessor(policyFactory, extensionProcessor)); + staxProcessors.addArtifactProcessor(new PolicySetProcessor(policyFactory, extensionProcessor)); + staxProcessors.addArtifactProcessor(new ImplementationTypeProcessor(policyFactory, intentAttachPointFactory, extensionProcessor)); + staxProcessors.addArtifactProcessor(new BindingTypeProcessor(policyFactory, intentAttachPointFactory, extensionProcessor)); + } + + + public SCADefinitions read(URL contributionURL, URI uri, URL url) throws ContributionReadException { + InputStream urlStream = null; + try { + URLConnection connection = url.openConnection(); + connection.setUseCaches(false); + urlStream = connection.getInputStream(); + //urlStream = createInputStream(url); + XMLStreamReader reader = inputFactory.createXMLStreamReader(url.toString(), urlStream); + + SCADefinitions scaDefns = new SCADefinitionsImpl(); + QName name = null; + int event; + while ( reader.hasNext() ) { + event = reader.next(); + + if ( event == XMLStreamConstants.START_ELEMENT || + event == XMLStreamConstants.END_ELEMENT ) { + name = reader.getName(); + if ( name.equals(tuscanyDefinitions) ) { + if ( event == XMLStreamConstants.END_ELEMENT ) { + return scaDefns; + } + } else { + SCADefinitions aDefn = (SCADefinitions)extensionProcessor.read(reader); + SCADefinitionsUtil.aggregateSCADefinitions(aDefn, scaDefns); + } + } + } + + return scaDefns; + } catch (XMLStreamException e) { + throw new ContributionReadException(e); + } catch (IOException e) { + throw new ContributionReadException(e); + } finally { + + try { + if (urlStream != null) { + urlStream.close(); + urlStream = null; + } + } catch (IOException ioe) { + //ignore + } + } + } + + public void resolve(SCADefinitions scaDefinitions, ModelResolver resolver) throws ContributionResolveException { + if ( resolver == null ) { + resolver = this.scaDefinitionsResolver; + } + SCADefinitionsUtil.stripDuplicates(scaDefinitions); + extensionProcessor.resolve(scaDefinitions, resolver); + } + + public String getArtifactType() { + return "definitions.xml"; + } + + public Class getModelType() { + return SCADefinitions.class; + } + + public ModelResolver getSCADefinitionsResolver() { + return scaDefinitionsResolver; + } + + public void setDomainModelResolver(ModelResolver scaDefnsModelResolver) { + this.scaDefinitionsResolver = scaDefnsModelResolver; + } +} diff --git a/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsProcessor.java b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsProcessor.java new file mode 100644 index 0000000000..7cb9087bd5 --- /dev/null +++ b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsProcessor.java @@ -0,0 +1,196 @@ +/* + * 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. + */ + +package org.apache.tuscany.sca.definitions.xml; + +import static javax.xml.stream.XMLStreamConstants.END_ELEMENT; +import static javax.xml.stream.XMLStreamConstants.START_ELEMENT; + +import javax.xml.namespace.QName; +import javax.xml.stream.XMLStreamConstants; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import javax.xml.stream.XMLStreamWriter; + +import org.apache.tuscany.sca.contribution.processor.BaseStAXArtifactProcessor; +import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor; +import org.apache.tuscany.sca.contribution.resolver.ModelResolver; +import org.apache.tuscany.sca.contribution.service.ContributionReadException; +import org.apache.tuscany.sca.contribution.service.ContributionResolveException; +import org.apache.tuscany.sca.contribution.service.ContributionWriteException; +import org.apache.tuscany.sca.definitions.SCADefinitions; +import org.apache.tuscany.sca.definitions.impl.SCADefinitionsImpl; +import org.apache.tuscany.sca.policy.Intent; +import org.apache.tuscany.sca.policy.IntentAttachPointType; +import org.apache.tuscany.sca.policy.PolicyFactory; +import org.apache.tuscany.sca.policy.PolicySet; +import org.apache.tuscany.sca.policy.QualifiedIntent; + +/** + * Processor for SCA Definitions + * + */ +public class SCADefinitionsProcessor extends BaseStAXArtifactProcessor implements StAXArtifactProcessor { + + private StAXArtifactProcessor extensionProcessor; + private ModelResolver definitionsResolver; + + public static final String BINDING = "binding"; + public static final String IMPLEMENTATION = "implementation"; + public static final String SCA10_NS = "http://www.osoa.org/xmlns/sca/1.0"; + public static final String SCA_DEFINITIONS = "definitions"; + public static final QName SCA_DEFINITIONS_QNAME = new QName(SCA10_NS, SCA_DEFINITIONS); + public static final String TARGET_NAMESPACE = "targetNamespace"; + public static final String NAME = "name"; + + /** + * Construct a new (sca) definitions processor + * @param policyFactory + * @param extensionProcessor + * @param modelResolver + */ + public SCADefinitionsProcessor(PolicyFactory policyFactory, + StAXArtifactProcessor extensionProcessor, + ModelResolver modelResolver) { + this.extensionProcessor = extensionProcessor; + this.definitionsResolver = modelResolver; + } + + public SCADefinitions read(XMLStreamReader reader) throws ContributionReadException, XMLStreamException { + QName name = null; + SCADefinitions definitions = null; + String targetNamespace = null; + + while (reader.hasNext()) { + int event = reader.getEventType(); + switch (event) { + case START_ELEMENT: { + name = reader.getName(); + if ( SCA_DEFINITIONS_QNAME.equals(name)) { + definitions = new SCADefinitionsImpl(); + targetNamespace = reader.getAttributeValue(null, TARGET_NAMESPACE); + definitions.setTargetNamespace(targetNamespace); + } else { + Object extension = extensionProcessor.read(reader); + if (extension != null) { + if ( extension instanceof Intent ) { + Intent intent = (Intent)extension; + intent.setName(new QName(targetNamespace, + intent.getName().getLocalPart())); + if ( intent instanceof QualifiedIntent ) { + QualifiedIntent qualifiedIntent = (QualifiedIntent)intent; + qualifiedIntent.getQualifiableIntent(). + setName(new QName(targetNamespace, + qualifiedIntent.getQualifiableIntent().getName().getLocalPart())); + } + + definitions.getPolicyIntents().add(intent); + } else if ( extension instanceof PolicySet ) { + PolicySet policySet = (PolicySet)extension; + policySet.setName(new QName(targetNamespace, + policySet.getName().getLocalPart())); + definitions.getPolicySets().add(policySet); + } else if ( extension instanceof IntentAttachPointType ) { + IntentAttachPointType type = (IntentAttachPointType)extension; + if ( type.getName().getLocalPart().startsWith(BINDING)) { + definitions.getBindingTypes().add((IntentAttachPointType)extension); + } else if ( type.getName().getLocalPart().startsWith(IMPLEMENTATION)) { + definitions.getImplementationTypes().add((IntentAttachPointType)extension); + } + } + definitionsResolver.addModel(extension); + } + break; + } + } + + case XMLStreamConstants.CHARACTERS: + break; + + case END_ELEMENT: + name = reader.getName(); + if ( SCA_DEFINITIONS_QNAME.equals(name)) { + return definitions; + } + break; + } + + //Read the next element + if (reader.hasNext()) { + reader.next(); + } + } + return definitions; + } + + public void write(SCADefinitions definitions, XMLStreamWriter writer) throws ContributionWriteException, XMLStreamException { + + writeStartDocument(writer, SCA10_NS, SCA_DEFINITIONS, + new XAttr(TARGET_NAMESPACE, definitions.getTargetNamespace().toString())); + + for (Intent policyIntent : definitions.getPolicyIntents()) { + extensionProcessor.write(policyIntent, writer); + } + + for (PolicySet policySet : definitions.getPolicySets()) { + extensionProcessor.write(policySet, writer); + } + + for (IntentAttachPointType bindingType : definitions.getBindingTypes()) { + extensionProcessor.write(bindingType, writer); + } + + for (IntentAttachPointType implType : definitions.getImplementationTypes()) { + extensionProcessor.write(implType, writer); + } + + writeEndDocument(writer); + } + + public void resolve(SCADefinitions scaDefns, ModelResolver resolver) throws ContributionResolveException { + for (int count = 0, size = scaDefns.getPolicyIntents().size(); count < size; count++) { + Intent intent = scaDefns.getPolicyIntents().get(count); + extensionProcessor.resolve(intent, resolver); + } + + for (int count = 0, size = scaDefns.getPolicySets().size(); count < size; count++) { + PolicySet policySet = scaDefns.getPolicySets().get(count); + extensionProcessor.resolve(policySet, resolver); + } + + for (int count = 0, size = scaDefns.getBindingTypes().size(); count < size; count++) { + IntentAttachPointType bindingType = scaDefns.getBindingTypes().get(count); + extensionProcessor.resolve(bindingType, resolver); + } + + for (int count = 0, size = scaDefns.getImplementationTypes().size(); count < size; count++) { + IntentAttachPointType implType = scaDefns.getImplementationTypes().get(count); + extensionProcessor.resolve(implType, resolver); + } + } + + public QName getArtifactType() { + return SCA_DEFINITIONS_QNAME; + } + + public Class getModelType() { + return SCADefinitions.class; + } + +} diff --git a/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsResolver.java b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsResolver.java new file mode 100644 index 0000000000..02fc114e24 --- /dev/null +++ b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/java/org/apache/tuscany/sca/definitions/xml/SCADefinitionsResolver.java @@ -0,0 +1,52 @@ +/* + * 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. + */ +package org.apache.tuscany.sca.definitions.xml; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.tuscany.sca.contribution.resolver.ModelResolver; + +/** + * Resolver for artifacts defined in definitions.xml + * + */ +public class SCADefinitionsResolver implements ModelResolver { + private Map map = new HashMap(); + + public SCADefinitionsResolver() { + } + + public void addModel(Object resolved) { + map.put(resolved, resolved); + } + + public Object removeModel(Object resolved) { + return map.remove(resolved); + } + + @SuppressWarnings("unchecked") + public T resolveModel(Class modelClass, T unresolved) { + Object resolved = map.get(unresolved); + if (resolved != null) { + return (T)resolved; + } + return unresolved; + } +} diff --git a/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor new file mode 100644 index 0000000000..6ed79d85b4 --- /dev/null +++ b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor @@ -0,0 +1,19 @@ +# 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. + +# Implementation class for the artifact processor extension +#org.apache.tuscany.sca.definitions.xml.SCADefinitionsProcessor;qname=http://www.osoa.org/xmlns/sca/1.0#definitions,model=org.apache.tuscany.sca.definitions.SCADefinitions diff --git a/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/MockPolicyProcessor.java b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/MockPolicyProcessor.java new file mode 100644 index 0000000000..467cc6cbe9 --- /dev/null +++ b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/MockPolicyProcessor.java @@ -0,0 +1,74 @@ +/* + * 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. + */ +package org.apache.tuscany.sca.definitions; + +import javax.xml.namespace.QName; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import javax.xml.stream.XMLStreamWriter; + +import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor; +import org.apache.tuscany.sca.contribution.resolver.ModelResolver; +import org.apache.tuscany.sca.contribution.service.ContributionReadException; +import org.apache.tuscany.sca.contribution.service.ContributionResolveException; +import org.apache.tuscany.sca.contribution.service.ContributionWriteException; +import org.apache.tuscany.sca.policy.Policy; + +/** + * @author administrator + * + */ +public class MockPolicyProcessor implements StAXArtifactProcessor { + + public QName getArtifactType() { + return new QName("http://schemas.xmlsoap.org/ws/2004/09/policy", "PolicyAttachment"); + } + + public Policy read(XMLStreamReader arg0) throws ContributionReadException, XMLStreamException { + return new MockPolicyImplOne(); + } + + public void write(Policy arg0, XMLStreamWriter arg1) throws ContributionWriteException, + XMLStreamException { + } + + public Class getModelType() { + // TODO Auto-generated method stub + return Policy.class; + } + + public void resolve(Policy arg0, ModelResolver arg1) throws ContributionResolveException { + + } + + + public class MockPolicyImplOne implements Policy { + public QName getSchemaName() { + return new QName("http://schemas.xmlsoap.org/ws/2004/09/policy", "PolicyAttachment"); + } + + public boolean isUnresolved() { + return false; + } + + public void setUnresolved(boolean unresolved) { + } + + } +} diff --git a/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/Policy.java b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/Policy.java new file mode 100644 index 0000000000..700d3d9d12 --- /dev/null +++ b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/Policy.java @@ -0,0 +1,32 @@ +/* + * 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. + */ +package org.apache.tuscany.sca.definitions; + +import javax.xml.namespace.QName; + +/** + * Interface that will abstract various types of policy specifications + * and attachments for example WS-Policy + * + */ +public interface Policy { + QName getSchemaName(); + void setUnresolved(boolean unresolved); + boolean isUnresolved(); +} diff --git a/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/ReadDocumentTestCase.java b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/ReadDocumentTestCase.java new file mode 100644 index 0000000000..7fb3810618 --- /dev/null +++ b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/java/org/apache/tuscany/sca/definitions/ReadDocumentTestCase.java @@ -0,0 +1,204 @@ +/* + * 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. + */ + +package org.apache.tuscany.sca.definitions; + +import java.net.URI; +import java.net.URL; +import java.util.Hashtable; +import java.util.Map; + +import javax.xml.namespace.QName; +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLOutputFactory; + +import junit.framework.TestCase; + +import org.apache.tuscany.sca.contribution.DefaultModelFactoryExtensionPoint; +import org.apache.tuscany.sca.contribution.processor.DefaultStAXArtifactProcessorExtensionPoint; +import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor; +import org.apache.tuscany.sca.definitions.xml.SCADefinitionsDocumentProcessor; +import org.apache.tuscany.sca.policy.DefaultIntentAttachPointTypeFactory; +import org.apache.tuscany.sca.policy.DefaultPolicyFactory; +import org.apache.tuscany.sca.policy.Intent; +import org.apache.tuscany.sca.policy.IntentAttachPointType; +import org.apache.tuscany.sca.policy.IntentAttachPointTypeFactory; +import org.apache.tuscany.sca.policy.PolicyFactory; +import org.apache.tuscany.sca.policy.PolicySet; +import org.apache.tuscany.sca.policy.ProfileIntent; +import org.apache.tuscany.sca.policy.QualifiedIntent; + +/** + * Test reading SCA XML assembly documents. + * + * @version $Rev: 551296 $ $Date: 2007-06-28 01:18:35 +0530 (Thu, 28 Jun 2007) $ + */ +public class ReadDocumentTestCase extends TestCase { + + //private ModelResolver resolver; + private SCADefinitionsDocumentProcessor scaDefnDocProcessor = null; + private SCADefinitions scaDefinitions; + Map intentTable = new Hashtable(); + Map policySetTable = new Hashtable(); + Map bindingTypesTable = new Hashtable(); + Map implTypesTable = new Hashtable(); + public static final String scaNamespace = "http://www.osoa.org/xmlns/sca/1.0"; + public static final String namespace = "http://test"; + + private static final QName secureWsPolicy = new QName(namespace, "SecureWSPolicy"); + private static final QName confidentiality = new QName(namespace, "confidentiality"); + private static final QName integrity = new QName(namespace, "integrity"); + private static final QName messageProtection = new QName(namespace, "messageProtection"); + private static final QName confidentiality_transport = new QName(namespace, "confidentiality.transport"); + private static final QName confidentiality_message = new QName(namespace, "confidentiality.message"); + private static final QName secureReliablePolicy = new QName(namespace, "SecureReliablePolicy"); + private static final QName secureMessagingPolicies = new QName(namespace, "SecureMessagingPolicies"); + private static final QName securityPolicy = new QName(namespace, "SecurityPolicy"); + private static final QName basicAuthMsgProtSecurity = new QName(namespace, "BasicAuthMsgProtSecurity"); + private static final QName wsBinding = new QName(scaNamespace, "binding.ws"); + private static final QName javaImpl = new QName(scaNamespace, "implementation.java"); + + + @Override + public void setUp() throws Exception { + XMLInputFactory inputFactory = XMLInputFactory.newInstance(); + PolicyFactory policyFactory = new DefaultPolicyFactory(); + IntentAttachPointTypeFactory intentAttachPointFactory = new DefaultIntentAttachPointTypeFactory(); + + // Create Stax processors + DefaultStAXArtifactProcessorExtensionPoint staxProcessors = new DefaultStAXArtifactProcessorExtensionPoint(new DefaultModelFactoryExtensionPoint()); + ExtensibleStAXArtifactProcessor staxProcessor = new ExtensibleStAXArtifactProcessor(staxProcessors, XMLInputFactory.newInstance(), XMLOutputFactory.newInstance()); + staxProcessors.addArtifactProcessor(new MockPolicyProcessor()); + + scaDefnDocProcessor = new SCADefinitionsDocumentProcessor(staxProcessors, + staxProcessor, + inputFactory, + policyFactory); + + URL url = getClass().getResource("test_definitions.xml"); + URI uri = URI.create("test_definitions.xml"); + scaDefinitions = scaDefnDocProcessor.read(null, uri, url); + + for ( Intent intent : scaDefinitions.getPolicyIntents() ) { + intentTable.put(intent.getName(), intent); + } + + for ( PolicySet policySet : scaDefinitions.getPolicySets() ) { + policySetTable.put(policySet.getName(), policySet); + } + + for ( IntentAttachPointType bindingType : scaDefinitions.getBindingTypes() ) { + bindingTypesTable.put(bindingType.getName(), bindingType); + } + + for ( IntentAttachPointType implType : scaDefinitions.getImplementationTypes() ) { + implTypesTable.put(implType.getName(), implType); + } + } + + @Override + public void tearDown() throws Exception { + scaDefnDocProcessor = null; + } + + public void testReadSCADefinitions() throws Exception { + assertNotNull(scaDefinitions); + + assertNotNull(intentTable.get(confidentiality)); + assertNotNull(intentTable.get(messageProtection)); + assertNotNull(intentTable.get(confidentiality_transport)); + assertTrue(intentTable.get(confidentiality).getDescription().length() > 0 ); + + assertNotNull(policySetTable.get(secureReliablePolicy)); + assertTrue(policySetTable.get(secureReliablePolicy).getProvidedIntents().size() == 2); + assertTrue(policySetTable.get(secureReliablePolicy).getPolicies().size() == 2); + + assertNotNull(policySetTable.get(secureMessagingPolicies)); + assertEquals(policySetTable.get(secureMessagingPolicies).getMappedPolicies().size(), 3); + //assertTrue(policySetTable.get(secureWsPolicy).getPolicies().get(0) instanceof org.apache.neethi.Policy); + + assertEquals(bindingTypesTable.size(), 1); + assertNotNull(bindingTypesTable.get(wsBinding)); + assertEquals(implTypesTable.size(), 1); + assertNotNull(implTypesTable.get(javaImpl)); + } + + public void testResolveSCADefinitions() throws Exception { + assertTrue(intentTable.get(messageProtection) instanceof ProfileIntent); + ProfileIntent profileIntent = (ProfileIntent)intentTable.get(new QName(namespace, "messageProtection")); + assertNull(profileIntent.getRequiredIntents().get(0).getDescription()); + + QName confidentiality_transport = new QName(namespace, "confidentiality.transport"); + assertTrue(intentTable.get(confidentiality_transport) instanceof QualifiedIntent); + QualifiedIntent qualifiedIntent = (QualifiedIntent)intentTable.get(new QName(namespace, "confidentiality.transport")); + assertNull(qualifiedIntent.getQualifiableIntent().getDescription()); + + PolicySet secureReliablePolicySet = policySetTable.get(secureReliablePolicy); + PolicySet secureMessagingPolicySet = policySetTable.get(secureMessagingPolicies); + PolicySet securityPolicySet = policySetTable.get(securityPolicy); + + assertEquals(secureReliablePolicySet.getProvidedIntents().get(1).getName(), integrity); + assertNull(secureReliablePolicySet.getProvidedIntents().get(1).getDescription()); + assertTrue(secureMessagingPolicySet.isUnresolved()); + assertEquals(securityPolicySet.getMappedPolicies().size(), 5); + + //testing to ensure that inclusion of referred policy sets has not happened + PolicySet basicAuthMsgProtSecurityPolicySet = policySetTable.get(basicAuthMsgProtSecurity); + assertTrue(basicAuthMsgProtSecurityPolicySet.getPolicies().isEmpty()); + assertTrue(basicAuthMsgProtSecurityPolicySet.getMappedPolicies().isEmpty()); + + IntentAttachPointType wsBindingType = bindingTypesTable.get(wsBinding); + assertNull(wsBindingType.getAlwaysProvidedIntents().get(0).getDescription()); + assertNull(wsBindingType.getMayProvideIntents().get(0).getDescription()); + + IntentAttachPointType javaImplType = implTypesTable.get(javaImpl); + assertNull(javaImplType.getAlwaysProvidedIntents().get(0).getDescription()); + assertNull(javaImplType.getMayProvideIntents().get(0).getDescription()); + + scaDefnDocProcessor.resolve(scaDefinitions, null); + //builder.build(scaDefinitions); + + //testing if policy intents have been linked have property been linked up + assertNotNull(profileIntent.getRequiredIntents().get(0).getDescription()); + assertNotNull(qualifiedIntent.getQualifiableIntent().getDescription()); + assertEquals(secureReliablePolicySet.getProvidedIntents().get(1).getName(), integrity); + assertNotNull(secureReliablePolicySet.getProvidedIntents().get(1).getDescription()); + + //testing if policysets have been properly linked up with intents + assertFalse(secureMessagingPolicySet.isUnresolved()); + assertNotNull(secureMessagingPolicySet.getMappedPolicies().get(intentTable.get(confidentiality))); + assertNotNull(secureMessagingPolicySet.getMappedPolicies().get(intentTable.get(confidentiality_transport))); + + //testing if intent maps have been properly mapped to policies + assertFalse(securityPolicySet.isUnresolved()); + assertNotNull(securityPolicySet.getMappedPolicies().get(intentTable.get(confidentiality))); + assertNotNull(securityPolicySet.getMappedPolicies().get(intentTable.get(confidentiality_message))); + + //testing for inclusion of referred policysets + assertFalse(basicAuthMsgProtSecurityPolicySet.getPolicies().isEmpty()); + assertFalse(basicAuthMsgProtSecurityPolicySet.getMappedPolicies().isEmpty()); + assertNotNull(basicAuthMsgProtSecurityPolicySet.getMappedPolicies().get(intentTable.get(confidentiality_transport))); + + assertNotNull(wsBindingType.getAlwaysProvidedIntents().get(0).getDescription()); + assertNotNull(wsBindingType.getMayProvideIntents().get(0).getDescription()); + + assertNotNull(javaImplType.getAlwaysProvidedIntents().get(0).getDescription()); + assertNotNull(javaImplType.getMayProvideIntents().get(0).getDescription()); + } +} diff --git a/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/resources/org/apache/tuscany/sca/definitions/test_definitions.xml b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/resources/org/apache/tuscany/sca/definitions/test_definitions.xml new file mode 100644 index 0000000000..3728e8f2b4 --- /dev/null +++ b/sca-java-1.x/tags/1.2.1/modules/definitions-xml/src/test/resources/org/apache/tuscany/sca/definitions/test_definitions.xml @@ -0,0 +1,254 @@ + + + + + + + + + + + + Test Intent + + + + + + Protect messages from unauthorized reading or modification + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ... + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ... + + + + ... + + + + + + + + + + + sp:X509v3 + + + + + + + + + + + + + + + + + + Protect messages from unauthorized reading or modification + + + + + + Protect messages from unauthorized reading or modification + + + + + + + Communitcation thro this binding must prevent + unauthorized users from reading the messages. + + + + + + Communitcation thro this binding must prevent + unauthorized modification of the messages. + + + + + + Communitcation thro this binding required + Authentication. + + + + + + All messages to and from this implementation must be logged + + + + + + Need to figure out some description for this + + + + \ No newline at end of file -- cgit v1.2.3