gistfile1.txt

package voldemort;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Collections;
import java.util.List;

import voldemort.client.rebalance.RebalanceClusterPlan;
import voldemort.cluster.Cluster;
import voldemort.cluster.Node;
import voldemort.store.StoreDefinition;
import voldemort.utils.KeyDistributionGenerator;
import voldemort.xml.ClusterMapper;
import voldemort.xml.StoreDefinitionsMapper;

import com.google.common.collect.Lists;

public class UpdateXml3 {

    public static void main(String args[]) throws IOException {
        if(args.length != 2) {
            System.err.println("<cluster.xml_path> <stores.xml_path>");
            System.exit(-1);
        }

        String clusterXmlPath = args[0];
        String storesXmlPath = args[1];

        File clusterXml = new File(clusterXmlPath);
        File storesXml = new File(storesXmlPath);

        File parentDir = clusterXml.getParentFile();
        String directoryName = clusterXml.getParentFile().getName();

        if(!clusterXml.exists() || !storesXml.exists()) {
            System.err.println("<cluster.xml_path> <stores.xml_path>");
            System.exit(-1);
        }

        ClusterMapper clusterMapper = new ClusterMapper();
        Cluster cluster = clusterMapper.readCluster(clusterXml);

        StoreDefinitionsMapper storeDefMapper = new StoreDefinitionsMapper();
        List<StoreDefinition> storeDefs = storeDefMapper.readStoreList(storesXml);

        // Generate the number of nodes
        List<Node> newNodes = Lists.newArrayListWithCapacity(2 * cluster.getNumberOfNodes());

        int origNodes = cluster.getNumberOfNodes() / 2;
        for(int nodeId = 0; nodeId < origNodes; nodeId++) {
            List<Integer> secondPartitions = Lists.newArrayList();
            List<Integer> firstPartitions = Lists.newArrayList();
            List<Integer> partitions = Lists.newArrayList(cluster.getNodeById(nodeId)
                                                                 .getPartitionIds());
            partitions.addAll(cluster.getNodeById(origNodes + nodeId).getPartitionIds());
            Collections.shuffle(partitions);

            int numPartitionsPerZone = partitions.size() / 2;
            if(numPartitionsPerZone <= 0) {
                System.exit(-1);
            }

            for(int i = 0; i < numPartitionsPerZone; i++) {
                firstPartitions.add(partitions.get(i));
            }

            for(int i = numPartitionsPerZone; i < partitions.size(); i++) {
                secondPartitions.add(partitions.get(i));
            }
            // firstPartitions.addAll(cluster.getNodeById(nodeId).getPartitionIds());
            // secondPartitions.addAll(cluster.getNodeById(origNodes +
            // nodeId).getPartitionIds());
            //
            // int firstRemoved = firstPartitions.remove(new
            // Random().nextInt(firstPartitions.size()));
            // int secondRemoved = firstPartitions.remove(new
            // Random().nextInt(firstPartitions.size()));
            // // int secondHalfRemoved = firstPartitions.remove(new
            // // Random().nextInt(firstPartitions.size()));
            // int thirdRemoved = secondPartitions.remove(new
            // Random().nextInt(secondPartitions.size()));
            // int forthRemoved = secondPartitions.remove(new
            // Random().nextInt(secondPartitions.size()));
            // // int forthHalfRemoved = secondPartitions.remove(new
            // // Random().nextInt(secondPartitions.size()));

            // firstPartitions.add(thirdRemoved);
            // firstPartitions.add(forthRemoved);
            // // firstPartitions.add(forthHalfRemoved);
            // secondPartitions.add(firstRemoved);
            // secondPartitions.add(secondRemoved);
            // // secondPartitions.add(secondHalfRemoved);

            newNodes.add(new Node(cluster.getNodeById(nodeId).getId(),
                                  cluster.getNodeById(nodeId).getHost(),
                                  cluster.getNodeById(nodeId).getHttpPort(),
                                  cluster.getNodeById(nodeId).getSocketPort(),
                                  cluster.getNodeById(nodeId).getAdminPort(),
                                  cluster.getNodeById(nodeId).getZoneId(),
                                  firstPartitions));
            newNodes.add(new Node(cluster.getNodeById(nodeId + origNodes).getId(),
                                  cluster.getNodeById(nodeId + origNodes).getHost(),
                                  cluster.getNodeById(nodeId + origNodes).getHttpPort(),
                                  cluster.getNodeById(nodeId + origNodes).getSocketPort(),
                                  cluster.getNodeById(nodeId + origNodes).getAdminPort(),
                                  cluster.getNodeById(nodeId + origNodes).getZoneId(),
                                  secondPartitions));
        }

        Cluster newCluster = new Cluster(cluster.getName(),
                                         newNodes,
                                         Lists.newArrayList(cluster.getZones()));

        RebalanceClusterPlan plan = new RebalanceClusterPlan(cluster,
                                                             newCluster,
                                                             storeDefs,
                                                             false,
                                                             null);

        System.out.println("PLAN = " + plan);
        File newClusterXml = new File(parentDir, directoryName + "_cluster_2.xml");
        String clusterString = clusterMapper.writeCluster(newCluster);

        for(StoreDefinition def: storeDefs) {
            System.out.println("FOR STORE = " + def.getName() + " - ");
            KeyDistributionGenerator.printDistribution((KeyDistributionGenerator.generateDistribution(newCluster,
                                                                                                      def,
                                                                                                      10000)));
        }

        FileOutputStream stream = new FileOutputStream(newClusterXml);
        stream.write(clusterString.getBytes());
        stream.close();

    }
}