cxf-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From egl...@apache.org
Subject svn commit: r885426 - in /cxf/trunk: api/src/main/java/org/apache/cxf/clustering/ rt/core/src/main/java/org/apache/cxf/clustering/ systests/uncategorized/src/test/java/org/apache/cxf/systest/clustering/
Date Mon, 30 Nov 2009 13:46:35 GMT
Author: eglynn
Date: Mon Nov 30 13:46:34 2009
New Revision: 885426

URL: http://svn.apache.org/viewvc?rev=885426&view=rev
Log:
Allowing failover addresses to be overridden in configuration

Added:
    cxf/trunk/systests/uncategorized/src/test/java/org/apache/cxf/systest/clustering/FailoverAddressOverrideTest.java
    cxf/trunk/systests/uncategorized/src/test/java/org/apache/cxf/systest/clustering/failover_address_override.xml
Modified:
    cxf/trunk/api/src/main/java/org/apache/cxf/clustering/FailoverStrategy.java
    cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/AbstractStaticFailoverStrategy.java
    cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/FailoverTargetSelector.java
    cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/Messages.properties
    cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/RandomStrategy.java
    cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/SequentialStrategy.java

Modified: cxf/trunk/api/src/main/java/org/apache/cxf/clustering/FailoverStrategy.java
URL: http://svn.apache.org/viewvc/cxf/trunk/api/src/main/java/org/apache/cxf/clustering/FailoverStrategy.java?rev=885426&r1=885425&r2=885426&view=diff
==============================================================================
--- cxf/trunk/api/src/main/java/org/apache/cxf/clustering/FailoverStrategy.java (original)
+++ cxf/trunk/api/src/main/java/org/apache/cxf/clustering/FailoverStrategy.java Mon Nov 30
13:46:34 2009
@@ -44,4 +44,21 @@
      * @return the selected endpoint
      */
     Endpoint selectAlternateEndpoint(List<Endpoint> alternates);
+
+    /**
+     * Get the alternate addresses for this invocation.
+     * These addresses over-ride any addresses specified in the WSDL.
+     * 
+     * @param exchange the current Exchange     
+     * @return a failover endpoint if one is available
+     */
+    List<String> getAlternateAddresses(Exchange exchange);
+
+    /**
+     * Select one of the alternate addresses for a retried invocation.
+     * 
+     * @param alternates List of alternate addresses if available
+     * @return the selected address
+     */
+    String selectAlternateAddress(List<String> addresses);
 }

Modified: cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/AbstractStaticFailoverStrategy.java
URL: http://svn.apache.org/viewvc/cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/AbstractStaticFailoverStrategy.java?rev=885426&r1=885425&r2=885426&view=diff
==============================================================================
--- cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/AbstractStaticFailoverStrategy.java
(original)
+++ cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/AbstractStaticFailoverStrategy.java
Mon Nov 30 13:46:34 2009
@@ -38,10 +38,47 @@
  * multiple endpoints associated with the same service instance.
  */
 public abstract class AbstractStaticFailoverStrategy implements FailoverStrategy {
-    
     private static final Logger LOG =
         LogUtils.getL7dLogger(AbstractStaticFailoverStrategy.class);
-    
+
+    private List<String> alternateAddresses;
+
+
+    public void setAlternateAddresses(List<String> alternateAddresses) {
+        this.alternateAddresses = alternateAddresses;
+    }
+   
+    /**
+     * Get the alternate addresses for this invocation.
+     * 
+     * @param exchange the current Exchange
+     * @return a List of alternate addresses if available
+     */
+    public List<String> getAlternateAddresses(Exchange exchange) {
+        return alternateAddresses != null
+               ? new ArrayList<String>(alternateAddresses)
+               : null;
+    }
+
+    /**
+     * Select one of the alternate addresses for a retried invocation.
+     * 
+     * @param a List of alternate addresses if available
+     * @return the selected address
+     */
+    public String selectAlternateAddress(List<String> alternates) {
+        String selected = null;
+        if (alternates != null && alternates.size() > 0) {
+            selected = getNextAlternate(alternates);
+            LOG.log(Level.WARNING,
+                    "FAILING_OVER_TO_ADDRESS_OVERRIDE",
+                    selected);
+        } else {
+            LOG.warning("NO_ALTERNATE_TARGETS_REMAIN");
+        }
+        return selected;
+    }
+
     /**
      * Get the alternate endpoints for this invocation.
      * 
@@ -53,6 +90,26 @@
     }
     
     /**
+     * Select one of the alternate endpoints for a retried invocation.
+     * 
+     * @param a List of alternate endpoints if available
+     * @return the selected endpoint
+     */
+    public Endpoint selectAlternateEndpoint(List<Endpoint> alternates) {
+        Endpoint selected = null;
+        if (alternates != null && alternates.size() > 0) {
+            selected = getNextAlternate(alternates);
+            LOG.log(Level.WARNING,
+                    "FAILING_OVER_TO_ALTERNATE_ENDPOINT",
+                     new Object[] {selected.getEndpointInfo().getName(),
+                                   selected.getEndpointInfo().getAddress()});
+        } else {
+            LOG.warning("NO_ALTERNATE_TARGETS_REMAIN");
+        }
+        return selected;
+    }
+    
+    /**
      * Get the endpoints for this invocation.
      * 
      * @param exchange the current Exchange
@@ -91,30 +148,10 @@
     }
 
     /**
-     * Select one of the alternate endpoints for a retried invocation.
-     * 
-     * @param a List of alternate endpoints if available
-     * @return the selected endpoint
-     */
-    public Endpoint selectAlternateEndpoint(List<Endpoint> alternates) {
-        Endpoint selected = null;
-        if (alternates != null && alternates.size() > 0) {
-            selected = getNextAlternate(alternates);
-            LOG.log(Level.WARNING,
-                    "FAILING_OVER_TO",
-                     new Object[] {selected.getEndpointInfo().getName(),
-                                   selected.getEndpointInfo().getAddress()});
-        } else {
-            LOG.warning("NO_ALTERNATE_TARGETS_REMAIN");
-        }
-        return selected;
-    }
-    
-    /**
      * Get next alternate endpoint.
      * 
      * @param alternates non-empty List of alternate endpoints 
      * @return
      */
-    protected abstract Endpoint getNextAlternate(List<Endpoint> alternates);
+    protected abstract <T> T getNextAlternate(List<T> alternates);
 }

Modified: cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/FailoverTargetSelector.java
URL: http://svn.apache.org/viewvc/cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/FailoverTargetSelector.java?rev=885426&r1=885425&r2=885426&view=diff
==============================================================================
--- cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/FailoverTargetSelector.java
(original)
+++ cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/FailoverTargetSelector.java
Mon Nov 30 13:46:34 2009
@@ -102,7 +102,7 @@
     }
 
     /**
-     * Called on completion of the MEP for which the Conduit was required.
+     * Called on completion of the MEP for which the Condit was required.
      * 
      * @param exchange represents the completed MEP
      */
@@ -116,7 +116,7 @@
         if (requiresFailover(exchange)) {
             Endpoint failoverTarget = getFailoverTarget(exchange, invocation);
             if (failoverTarget != null) {
-                endpoint = failoverTarget;
+                setEndpoint(failoverTarget);
                 selectedConduit.close();
                 selectedConduit = null;
                 Exception prevExchangeFault =
@@ -146,12 +146,7 @@
                     }
                 }
             } else {
-                if (endpoint != invocation.getOriginalEndpoint()) {
-                    endpoint = invocation.getOriginalEndpoint();
-                    getLogger().log(Level.INFO,
-                                    "REVERT_TO_ORIGINAL_TARGET",
-                                    endpoint.getEndpointInfo().getName());
-                }
+                setEndpoint(invocation.retrieveOriginalEndpoint(endpoint));
             }
         }
         if (!failover) {
@@ -225,16 +220,39 @@
      * @return a failover endpoint if one is available
      */
     private Endpoint getFailoverTarget(Exchange exchange,
-                                       InvocationContext invocation) {        
-        if (invocation.getAlternateTargets() == null) {
+                                       InvocationContext invocation) {
+        List<String> alternateAddresses = null;
+        if (!invocation.hasAlternates()) {
             // no previous failover attempt on this invocation
             //
-            invocation.setAlternateTargets(
-                getStrategy().getAlternateEndpoints(exchange));
-        } 
+            alternateAddresses = 
+                getStrategy().getAlternateAddresses(exchange);
+            if (alternateAddresses != null) {
+                invocation.setAlternateAddresses(alternateAddresses);
+            } else {
+                invocation.setAlternateEndpoints(
+                    getStrategy().getAlternateEndpoints(exchange));
+            }
+        } else {
+            alternateAddresses = invocation.getAlternateAddresses();
+        }
 
-        return getStrategy().selectAlternateEndpoint(
-                   invocation.getAlternateTargets());
+        Endpoint failoverTarget = null;
+        if (alternateAddresses != null) {
+            String alternateAddress = 
+                getStrategy().selectAlternateAddress(alternateAddresses);
+            if (alternateAddress != null) {
+                // re-use current endpoint
+                //
+                failoverTarget = getEndpoint();
+
+                failoverTarget.getEndpointInfo().setAddress(alternateAddress);
+            }
+        } else {
+            failoverTarget = getStrategy().selectAlternateEndpoint(
+                                 invocation.getAlternateEndpoints());
+        }
+        return failoverTarget;
     }
     
     /**
@@ -282,24 +300,38 @@
     /**
      * Records the context of an invocation.
      */
-    private static class InvocationContext {
+    private class InvocationContext {
         private Endpoint originalEndpoint;
+        private String originalAddress;
         private BindingOperationInfo bindingOperationInfo;
         private Object[] params; 
         private Map<String, Object> context;
-        private List<Endpoint> alternateTargets;
+        private List<Endpoint> alternateEndpoints;
+        private List<String> alternateAddresses;
         
         InvocationContext(Endpoint endpoint,
                           BindingOperationInfo boi,
                           Object[] prms, 
                           Map<String, Object> ctx) {
             originalEndpoint = endpoint;
+            originalAddress = endpoint.getEndpointInfo().getAddress();
             bindingOperationInfo = boi;
             params = prms;
             context = ctx;
         }
 
-        Endpoint getOriginalEndpoint() {
+        Endpoint retrieveOriginalEndpoint(Endpoint endpoint) {
+            if (endpoint != originalEndpoint) {
+                getLogger().log(Level.INFO,
+                                "REVERT_TO_ORIGINAL_TARGET",
+                                endpoint.getEndpointInfo().getName());
+            }
+            if (!endpoint.getEndpointInfo().getAddress().equals(originalAddress)) {
+                endpoint.getEndpointInfo().setAddress(originalAddress);
+                getLogger().log(Level.INFO,
+                                "REVERT_TO_ORIGINAL_ADDRESS",
+                                endpoint.getEndpointInfo().getAddress());
+            }
             return originalEndpoint;
         }
         
@@ -315,12 +347,24 @@
             return context;
         }
         
-        List<Endpoint> getAlternateTargets() {
-            return alternateTargets;
+        List<Endpoint> getAlternateEndpoints() {
+            return alternateEndpoints;
+        }
+
+        List<String> getAlternateAddresses() {
+            return alternateAddresses;
+        }
+
+        void setAlternateEndpoints(List<Endpoint> alternates) {
+            alternateEndpoints = alternates;
+        }
+
+        void setAlternateAddresses(List<String> alternates) {
+            alternateAddresses = alternates;
         }
 
-        void setAlternateTargets(List<Endpoint> alternates) {
-            alternateTargets = alternates;
+        boolean hasAlternates() {
+            return !(alternateEndpoints == null && alternateAddresses == null);
         }
     }    
 }

Modified: cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/Messages.properties
URL: http://svn.apache.org/viewvc/cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/Messages.properties?rev=885426&r1=885425&r2=885426&view=diff
==============================================================================
--- cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/Messages.properties (original)
+++ cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/Messages.properties Mon Nov
30 13:46:34 2009
@@ -20,10 +20,12 @@
 #
 USING_STRATEGY = Using failover strategy {0}
 REVERT_TO_ORIGINAL_TARGET = reverted to original endpoint {0}
+REVERT_TO_ORIGINAL_ADDRESS = reverted to original address {0}
 FAILOVER_NOT_REQUIRED = failover not required
 NO_ALTERNATE_TARGETS_REMAIN = no alternate targets remain => giving up on failover
 CHECK_LAST_INVOKE_FAILED = last invocation raised fault?: {0}
 CHECK_FAILURE_IN_TRANSPORT = failure {0} caused at transport level?: {1}
 FAILOVER_CANDIDATE_ACCEPTED = failover candidate {0} accepted
 FAILOVER_CANDIDATE_REJECTED = failover candidate {0} rejected on binding mismatch
-FAILING_OVER_TO = failing over to alternate target {0}
\ No newline at end of file
+FAILING_OVER_TO_ALTERNATE_ENDPOINT = failing over to alternate target {0}
+FAILING_OVER_TO_ADRESS_OVERRIDE = failing over to alternate address {0}

Modified: cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/RandomStrategy.java
URL: http://svn.apache.org/viewvc/cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/RandomStrategy.java?rev=885426&r1=885425&r2=885426&view=diff
==============================================================================
--- cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/RandomStrategy.java (original)
+++ cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/RandomStrategy.java Mon Nov
30 13:46:34 2009
@@ -22,8 +22,6 @@
 import java.util.List;
 import java.util.Random;
 
-import org.apache.cxf.endpoint.Endpoint;
-
 /**
  * Failover strategy based on a randomized walk through the
  * static cluster represented by multiple endpoints associated 
@@ -46,7 +44,7 @@
      * @param alternates non-empty List of alternate endpoints 
      * @return
      */
-    protected Endpoint getNextAlternate(List<Endpoint> alternates) {
+    protected <T> T getNextAlternate(List<T> alternates) {
         return alternates.remove(random.nextInt(alternates.size()));
     }
 }
\ No newline at end of file

Modified: cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/SequentialStrategy.java
URL: http://svn.apache.org/viewvc/cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/SequentialStrategy.java?rev=885426&r1=885425&r2=885426&view=diff
==============================================================================
--- cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/SequentialStrategy.java (original)
+++ cxf/trunk/rt/core/src/main/java/org/apache/cxf/clustering/SequentialStrategy.java Mon
Nov 30 13:46:34 2009
@@ -21,8 +21,6 @@
 
 import java.util.List;
 
-import org.apache.cxf.endpoint.Endpoint;
-
 /**
  * Failover strategy based on a sequential walk through the
  * static cluster represented by multiple endpoints associated 
@@ -36,7 +34,7 @@
      * @param alternates non-empty List of alternate endpoints 
      * @return
      */
-    protected Endpoint getNextAlternate(List<Endpoint> alternates) {
+    protected <T> T getNextAlternate(List<T> alternates) {
         return alternates.remove(0);
     }
 }

Added: cxf/trunk/systests/uncategorized/src/test/java/org/apache/cxf/systest/clustering/FailoverAddressOverrideTest.java
URL: http://svn.apache.org/viewvc/cxf/trunk/systests/uncategorized/src/test/java/org/apache/cxf/systest/clustering/FailoverAddressOverrideTest.java?rev=885426&view=auto
==============================================================================
--- cxf/trunk/systests/uncategorized/src/test/java/org/apache/cxf/systest/clustering/FailoverAddressOverrideTest.java
(added)
+++ cxf/trunk/systests/uncategorized/src/test/java/org/apache/cxf/systest/clustering/FailoverAddressOverrideTest.java
Mon Nov 30 13:46:34 2009
@@ -0,0 +1,252 @@
+/**
+ * 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.cxf.systest.clustering;
+
+import java.net.ConnectException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.bus.spring.SpringBusFactory;
+import org.apache.cxf.clustering.AbstractStaticFailoverStrategy;
+import org.apache.cxf.clustering.FailoverTargetSelector;
+import org.apache.cxf.clustering.RandomStrategy;
+import org.apache.cxf.clustering.SequentialStrategy;
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.endpoint.ConduitSelector;
+import org.apache.cxf.endpoint.Endpoint;
+import org.apache.cxf.frontend.ClientProxy;
+import org.apache.cxf.greeter_control.ClusteredGreeterService;
+import org.apache.cxf.greeter_control.Control;
+import org.apache.cxf.greeter_control.ControlService;
+import org.apache.cxf.greeter_control.Greeter;
+import org.apache.cxf.testutil.common.AbstractBusClientServerTestBase;
+import org.apache.cxf.ws.addressing.MAPAggregator;
+import org.apache.cxf.ws.addressing.soap.MAPCodec;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+
+/**
+ * Tests failover within a static cluster.
+ */
+public class FailoverAddressOverrideTest extends AbstractBusClientServerTestBase {
+
+    protected static final String REPLICA_A =
+        "http://localhost:9051/SoapContext/ReplicatedPortA";
+    protected static final String REPLICA_B =
+        "http://localhost:9052/SoapContext/ReplicatedPortB"; 
+    protected static final String REPLICA_C =
+        "http://localhost:9053/SoapContext/ReplicatedPortC"; 
+    protected static final String REPLICA_D =
+        "http://localhost:9054/SoapContext/ReplicatedPortD"; 
+    private static final Logger LOG =
+        LogUtils.getLogger(FailoverTest.class);
+    private static final String FAILOVER_CONFIG =
+        "org/apache/cxf/systest/clustering/failover_address_override.xml";
+
+    private Bus bus;
+    private Control control;
+    private Greeter greeter;
+    private List<String> targets;
+    private MAPAggregator mapAggregator;
+    private MAPCodec mapCodec;
+
+
+    @BeforeClass
+    public static void startServers() throws Exception {
+        assertTrue("server did not launch correctly",
+                   launchServer(Server.class));
+    }
+            
+    @Before
+    public void setUp() {
+        targets = new ArrayList<String>();
+        SpringBusFactory bf = new SpringBusFactory();    
+        bus = bf.createBus(FAILOVER_CONFIG);
+        BusFactory.setDefaultBus(bus);
+    }
+    
+    @After
+    public void tearDown() {
+        if (null != control) {
+            for (String address : targets) {
+                assertTrue("Failed to stop greeter",
+                           control.stopGreeter(address));
+            }
+        }
+        targets = null;
+        if (bus != null) {
+            bus.shutdown(true);
+        }
+    }
+
+
+    //@Test
+    public void testOverriddenSequentialStrategy() throws Exception {
+        startTarget(REPLICA_C);
+        setupGreeterA();
+        verifyStrategy(greeter, SequentialStrategy.class, 3);
+        String response = greeter.greetMe("fred");
+        assertNotNull("expected non-null response", response);
+        assertTrue("response from unexpected target: " + response,
+                   response.endsWith(REPLICA_C));
+        verifyCurrentEndpoint(REPLICA_C);
+        stopTarget(REPLICA_C);
+    }
+    
+    //@Test
+    public void testOverriddenRandomStrategy() throws Exception {
+        startTarget(REPLICA_B);
+        setupGreeterC();
+        verifyStrategy(greeter, RandomStrategy.class, 3);
+        String response = greeter.greetMe("fred");
+        assertNotNull("expected non-null response", response);
+        assertTrue("response from unexpected target: " + response,
+                   response.endsWith(REPLICA_B));
+        verifyCurrentEndpoint(REPLICA_B);
+        stopTarget(REPLICA_B);
+    }
+
+    @Test
+    public void testUnreachableAddresses() throws Exception {
+        startTarget(REPLICA_A);
+        setupGreeterB();
+        verifyStrategy(greeter, SequentialStrategy.class, 2);
+        try {
+            greeter.greetMe("fred");
+            fail("expected exception");
+        } catch (Exception e) {
+            Throwable cause = e;
+            while (cause.getCause() != null) {
+                cause = cause.getCause();
+            }
+            assertTrue("should revert to original exception when no failover: " 
+                       + cause,
+                       cause instanceof ConnectException);
+            verifyCurrentEndpoint(REPLICA_B.replaceFirst("9052", "15555"));
+        }
+        stopTarget(REPLICA_A);
+    }
+    
+
+    private void startTarget(String address) {
+        ControlService cs = new ControlService();
+        control = cs.getControlPort();
+
+        LOG.info("starting replicated target: " + address);
+        System.out.println("starting replicated target: " + address);
+        assertTrue("Failed to start greeter", control.startGreeter(address));
+        targets.add(address);
+    }
+    
+    private void stopTarget(String address) {
+        if (control != null
+            && targets.contains(address)) {
+            LOG.info("starting replicated target: " + address);
+            assertTrue("Failed to start greeter", control.stopGreeter(address));
+            targets.remove(address);
+        }
+    }
+
+    private void verifyCurrentEndpoint(String replica) {
+        assertEquals("unexpected current endpoint",
+                     replica,
+                     getCurrentEndpoint(greeter));
+    }
+    
+    private String getCurrentEndpoint(Object proxy) {
+        return ClientProxy.getClient(proxy).getEndpoint().getEndpointInfo().getAddress();
+    }
+    
+    private void setupGreeterA() {
+        greeter = new ClusteredGreeterService().getReplicatedPortA();
+        verifyConduitSelector(greeter);
+    }
+
+    private void setupGreeterB() {
+        greeter = new ClusteredGreeterService().getReplicatedPortB();
+        verifyConduitSelector(greeter);
+    }
+
+    private void setupGreeterC() {
+        greeter = new ClusteredGreeterService().getReplicatedPortC();
+        verifyConduitSelector(greeter);
+    }
+        
+    private void verifyConduitSelector(Greeter g) {
+        assertTrue("unexpected conduit slector",
+                   ClientProxy.getClient(g).getConduitSelector()
+                   instanceof FailoverTargetSelector);
+    }
+
+    private void verifyStrategy(Object proxy, Class clz, int count) {
+        ConduitSelector conduitSelector =
+            ClientProxy.getClient(proxy).getConduitSelector();
+        if (conduitSelector instanceof FailoverTargetSelector) {
+            AbstractStaticFailoverStrategy strategy = 
+                (AbstractStaticFailoverStrategy)
+                    ((FailoverTargetSelector)conduitSelector).getStrategy();
+            assertTrue("unexpected strategy", clz.isInstance(strategy));
+            List<String> alternates = strategy.getAlternateAddresses(null);
+            assertNotNull("expected alternate addresses", alternates);
+            assertEquals("unexpected alternate addresses", count, alternates.size());
+        } else {
+            fail("unexpected conduit selector: " + conduitSelector);
+        }
+    }
+
+    protected void enableWSAForCurrentEndpoint() {
+        Endpoint provider = ClientProxy.getClient(greeter).getEndpoint();
+        mapAggregator = new MAPAggregator();
+        mapCodec = new MAPCodec();
+        provider.getInInterceptors().add(mapAggregator);
+        provider.getInInterceptors().add(mapCodec);
+        
+        provider.getOutInterceptors().add(mapAggregator);
+        provider.getOutInterceptors().add(mapCodec);
+        
+        provider.getInFaultInterceptors().add(mapAggregator);
+        provider.getInFaultInterceptors().add(mapCodec);
+        
+        provider.getOutFaultInterceptors().add(mapAggregator);
+        provider.getOutFaultInterceptors().add(mapCodec);
+    }
+    
+    protected boolean isWSAEnabledForCurrentEndpoint() {
+        Endpoint provider = ClientProxy.getClient(greeter).getEndpoint();
+        boolean enabledIn = 
+            provider.getInInterceptors().contains(mapAggregator)
+            && provider.getInInterceptors().contains(mapCodec)
+            && provider.getInFaultInterceptors().contains(mapAggregator)
+            && provider.getInFaultInterceptors().contains(mapCodec);
+        boolean enabledOut = 
+            provider.getOutInterceptors().contains(mapAggregator)
+            && provider.getOutInterceptors().contains(mapCodec)
+            && provider.getOutFaultInterceptors().contains(mapAggregator)
+            && provider.getOutFaultInterceptors().contains(mapCodec);
+        return enabledIn && enabledOut;
+    }
+}

Added: cxf/trunk/systests/uncategorized/src/test/java/org/apache/cxf/systest/clustering/failover_address_override.xml
URL: http://svn.apache.org/viewvc/cxf/trunk/systests/uncategorized/src/test/java/org/apache/cxf/systest/clustering/failover_address_override.xml?rev=885426&view=auto
==============================================================================
--- cxf/trunk/systests/uncategorized/src/test/java/org/apache/cxf/systest/clustering/failover_address_override.xml
(added)
+++ cxf/trunk/systests/uncategorized/src/test/java/org/apache/cxf/systest/clustering/failover_address_override.xml
Mon Nov 30 13:46:34 2009
@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements. See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership. The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License. You may obtain a copy of the License at
+ 
+  http://www.apache.org/licenses/LICENSE-2.0
+ 
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied. See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:jaxws="http://cxf.apache.org/jaxws"
+       xmlns:clustering="http://cxf.apache.org/clustering"
+       xmlns:util="http://www.springframework.org/schema/util"
+       xsi:schemaLocation="
+http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd
+http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
+    
+    <util:list id="addressList">
+        <value>http://localhost:9051/SoapContext/ReplicatedPortA</value>
+        <value>http://localhost:9052/SoapContext/ReplicatedPortB</value>
+        <value>http://localhost:9053/SoapContext/ReplicatedPortC</value>
+    </util:list>
+
+    <bean id="SequentialAddresses" class="org.apache.cxf.clustering.SequentialStrategy">
+        <property name="alternateAddresses">
+            <ref bean="addressList"/>
+        </property>
+    </bean>
+
+    <bean id="RandomAddresses" class="org.apache.cxf.clustering.RandomStrategy">
+        <property name="alternateAddresses">
+            <ref bean="addressList"/>
+        </property>
+    </bean>
+
+    <bean id="UnreachableAddresses" class="org.apache.cxf.clustering.SequentialStrategy">
+        <property name="alternateAddresses">
+            <list>        
+                <value>http://localhost:9050/SoapContext/ReplicatedPortA</value>
+                <value>http://localhost:9053/SoapContext/ReplicatedPortC</value>
+            </list>
+        </property>
+    </bean>
+
+    <jaxws:client name="{http://cxf.apache.org/greeter_control}ReplicatedPortA"
+                  createdFromAPI="true">
+        <jaxws:features>
+            <clustering:failover>
+                <clustering:strategy>
+                    <ref bean="SequentialAddresses"/>
+                </clustering:strategy>
+            </clustering:failover>
+        </jaxws:features>
+    </jaxws:client>
+
+    <jaxws:client name="{http://cxf.apache.org/greeter_control}ReplicatedPortC"
+                  createdFromAPI="true">
+        <jaxws:features>
+            <clustering:failover>
+                <clustering:strategy>
+                    <ref bean="RandomAddresses"/>
+                </clustering:strategy>
+            </clustering:failover>
+        </jaxws:features>
+    </jaxws:client>
+
+    <jaxws:client name="{http://cxf.apache.org/greeter_control}ReplicatedPortB"
+                  address="http://localhost:15555/SoapContext/ReplicatedPortB"
+                  createdFromAPI="true">
+        <jaxws:features>
+            <clustering:failover>
+                <clustering:strategy>
+                    <ref bean="UnreachableAddresses"/>
+                </clustering:strategy>
+            </clustering:failover>
+        </jaxws:features>
+    </jaxws:client>
+    
+</beans>



Mime
View raw message