// This means, the getall will only succeed on two of the nodes

        timeoutConfig.setOperationTimeout(VoldemortOpCode.GET_ALL_OP_CODE, 250);

        RoutedStoreFactory routedStoreFactory = createFactory();

                                                            definition,

                                                            stores,

                                                            failureDetector,

                                                            createConfig(timeoutConfig));

        /* do some puts so we have some data to test getalls */

 

            zoneProximityList.addAll(zoneIds);

            zones.add(new Zone(i, zoneProximityList));

        }

                                                            definition,

                                                            stores,

                                                            failureDetector,

                                                            createConfig(timeoutConfig));

        /* do some puts so we have some data to test getalls */

 

        routedStoreThreadPool = Executors.newFixedThreadPool(3);

        RoutedStoreFactory routedStoreFactory = createFactory();

                                                            definition,

                                                            stores,

                                                            failureDetector,

                                                            createConfig(timeout));

    public StoreRoutingPlanTest() {}

    @Before

    public void setup() {

                1000, 2000, 3000, 1000, 2000, 3000 }, new int[][] { { 0 }, { 1, 3 }, { 2 } });

        StoreDefinition nonZoned211StoreDef = new StoreDefinitionBuilder().setName("non-zoned")

                                                                          .setType(BdbStorageConfiguration.TYPE_NAME)

                                                                          .setKeySerializer(new SerializerDefinition("string"))

                                                                          .setValueSerializer(new SerializerDefinition("string"))

                                                                          .setRoutingPolicy(RoutingTier.CLIENT)

                                                                          .setRoutingStrategyType(RoutingStrategyType.CONSISTENT_STRATEGY)

                                                                          .setReplicationFactor(2)

                                                                          .setPreferredReads(1)

                                                                          .setRequiredReads(1)

                                                                          .setPreferredWrites(1)

                                                                          .setRequiredWrites(1)

                                                                          .build();

        nonZonedBaseRoutingPlan = new BaseStoreRoutingPlan(nonZonedCluster, nonZoned211StoreDef);

        nonZonedStoreRoutingPlan = new StoreRoutingPlan(nonZonedCluster, nonZoned211StoreDef);

        int[] dummyZonedPorts = new int[] { 1000, 2000, 3000, 1000, 2000, 3000, 1000, 2000, 3000,

                1000, 2000, 3000, 1000, 2000, 3000, 1000, 2000, 3000 };

                                                                 2,

                                                                 new int[] { 0, 0, 0, 1, 1, 1 },

                                                                 new int[][] { { 0 }, { 1, 6 },

                                                                         { 2 }, { 3 }, { 4, 7 },

                                                                         { 5 } },

                                                                 dummyZonedPorts);

        HashMap<Integer, Integer> zrfRWStoreWithReplication = new HashMap<Integer, Integer>();

        zrfRWStoreWithReplication.put(0, 2);

        zrfRWStoreWithReplication.put(1, 2);

        StoreDefinition zz211StoreDef = new StoreDefinitionBuilder().setName("zoned")

                                                                    .setType(BdbStorageConfiguration.TYPE_NAME)

                                                                    .setKeySerializer(new SerializerDefinition("string"))

                                                                    .setValueSerializer(new SerializerDefinition("string"))

                                                                    .setRoutingPolicy(RoutingTier.CLIENT)

                                                                    .setRoutingStrategyType(RoutingStrategyType.ZONE_STRATEGY)

                                                                    .setReplicationFactor(4)

                                                                    .setPreferredReads(1)

                                                                    .setRequiredReads(1)

                                                                    .setPreferredWrites(1)

                                                                    .setRequiredWrites(1)

                                                                    .setZoneCountReads(0)

                                                                    .setZoneCountWrites(0)

                                                                    .setZoneReplicationFactor(zrfRWStoreWithReplication)

                                                                    .setHintedHandoffStrategy(HintedHandoffStrategyType.PROXIMITY_STRATEGY)

                                                                    .build();

        zzBaseRoutingPlan = new BaseStoreRoutingPlan(zzCluster, zz211StoreDef);

        zzStoreRoutingPlan = new StoreRoutingPlan(zzCluster, zz211StoreDef);

                1, 2, 2, 2 }, new int[][] { { 0 }, { 10 }, { 1, 2 }, { 3 }, { 4 }, { 6 }, { 5, 7 },

                { 9 }, { 8 } }, new int[] { 1000, 2000, 3000, 1000, 2000, 3000, 1000, 2000, 3000,

                1000, 2000, 3000, 1000, 2000, 3000, 1000, 2000, 3000, 1000, 2000, 3000, 1000, 2000,

                3000, 1000, 2000, 3000 });

        routedStoreThreadPool = Executors.newFixedThreadPool(3);

        RoutedStoreFactory routedStoreFactory = createFactory();

                                                            definition,

                                                            stores,

                                                            failureDetector,

                                                            createConfig(timeout));

    }

   

    @Before

    public void setupNonContiguous() {

        HashMap<Integer, Integer> zoneRep211 = new HashMap<Integer, Integer>();

        zoneRep211.put(1, 2);

        zoneRep211.put(3, 2);

        StoreDefinition z1z3211StoreDef = new StoreDefinitionBuilder().setName("z1z3211")

                                                                    .setType(BdbStorageConfiguration.TYPE_NAME)

                                                                    .setKeySerializer(new SerializerDefinition("string"))

                                                                    .setValueSerializer(new SerializerDefinition("string"))

                                                                    .setRoutingPolicy(RoutingTier.CLIENT)

                                                                    .setRoutingStrategyType(RoutingStrategyType.ZONE_STRATEGY)

                                                                    .setReplicationFactor(4)

                                                                    .setPreferredReads(1)

                                                                    .setRequiredReads(1)

                                                                    .setPreferredWrites(1)

                                                                    .setRequiredWrites(1)

                                                                    .setZoneCountReads(0)

                                                                    .setZoneCountWrites(0)

                                                                    .setZoneReplicationFactor(zoneRep211)

                                                                    .setHintedHandoffStrategy(HintedHandoffStrategyType.PROXIMITY_STRATEGY)

                                                                    .build();

        z1z3BaseRoutingPlan = new BaseStoreRoutingPlan(z1z3Current, z1z3211StoreDef);

        z1z3StoreRoutingPlan = new StoreRoutingPlan(z1z3Current, z1z3211StoreDef);

       

      

        // 3 zones

        HashMap<Integer, Integer> zoneRep3zones211 = new HashMap<Integer, Integer>();

    

        zoneRep3zones211.put(1, 2);

        zoneRep3zones211.put(3, 2);

        zoneRep3zones211.put(5, 2);

            zoneProximityList.addAll(zoneIds);

            zones.add(new Zone(i, zoneProximityList));

        }

                                                            definition,

                                                            stores,

                                                            failureDetector,

                                                            createConfig(timeout));

        TimeoutConfig timeoutConfig = new TimeoutConfig(1500, false);

        timeoutConfig.setOperationTimeout(VoldemortOpCode.GET_OP_CODE, 100);

        RoutedStoreFactory routedStoreFactory = createFactory();

                                                            definition,

                                                            stores,

                                                            failureDetector,

                                                            createConfig(timeoutConfig));

        try {

     */

    @Test

    public void testConfigureNodesLocalHost() throws Exception {

        List<Node> nodes = getTestNodes();

        FailureDetector failureDetector = new ThresholdFailureDetector(new FailureDetectorConfig().setCluster(cluster));

        BasicPipelineData<byte[]> pipelineData = new BasicPipelineData<byte[]>();

        ConfigureNodesLocalHost<byte[], BasicPipelineData<byte[]>> action = new ConfigureNodesLocalHost<byte[], BasicPipelineData<byte[]>>(pipelineData,

                                                                                                                                           Event.COMPLETED,

                                                                                                                                           failureDetector,

                                                                                                                                           1,

                                                                                                                                           routingStrategy,

                                                                                                                                           aKey);

        Pipeline pipeline = new Pipeline(Operation.GET, 10000, TimeUnit.MILLISECONDS);

        pipeline.addEventAction(Event.STARTED, action);

        pipeline.addEvent(Event.STARTED);

        pipeline.execute();

        if(pipelineData.getFatalError() != null)

            throw pipelineData.getFatalError();

        assertEquals(pipelineData.getNodes().get(0).getHost(), currentHost);

    }

    @Override

    public void setUp() throws Exception {

        super.setUp();

        context = ServerTestUtils.getJettyServer(new ClusterMapper().writeCluster(cluster),

                                                 VoldemortTestConstants.getSimpleStoreDefinitionsXml(),

                                                 "users",

                                                 RequestFormatType.VOLDEMORT_V1,

                                                 node.getHttpPort());