Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.apache.helix.util;
  
  /*
   * 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.
  */
 
 import java.util.List;
 import java.util.Map;
 
 
 
 public class RebalanceUtil {
   public static Map<StringObjectbuildInternalIdealState(IdealState state) {
     // Try parse the partition number from name DB_n. If not, sort the partitions and
     // assign id
     Map<StringIntegerpartitionIndex = new HashMap<StringInteger>();
     Map<StringStringreversePartitionIndex = new HashMap<StringString>();
     boolean indexInPartitionName = true;
     for (PartitionId partitionId : state.getPartitionIdSet()) {
       String partitionName = partitionId.stringify();
       int lastPos = partitionName.lastIndexOf("_");
       if (lastPos < 0) {
         indexInPartitionName = false;
         break;
       }
       try {
         String idStr = partitionName.substring(lastPos + 1);
         int partition = Integer.parseInt(idStr);
         partitionIndex.put(partitionNamepartition);
         reversePartitionIndex.put(state.getResourceId().stringify() + "_" + partition,
             partitionName);
       } catch (Exception e) {
         indexInPartitionName = false;
         partitionIndex.clear();
         reversePartitionIndex.clear();
         break;
       }
     }
 
     if (indexInPartitionName == false) {
       List<Stringpartitions = new ArrayList<String>();
       partitions.addAll(Lists.transform(Lists.newArrayList(state.getPartitionIdSet()),
           Functions.toStringFunction()));
       Collections.sort(partitions);
       for (int i = 0; i < partitions.size(); i++) {
         partitionIndex.put(partitions.get(i), i);
         reversePartitionIndex.put(state.getResourceId().stringify() + "_" + ipartitions.get(i));
       }
     }
 
     Map<StringList<Integer>> nodeMasterAssignmentMap = new TreeMap<StringList<Integer>>();
     Map<StringMap<StringList<Integer>>> combinedNodeSlaveAssignmentMap =
         new TreeMap<StringMap<StringList<Integer>>>();
     for (PartitionId partition : state.getPartitionIdSet()) {
       List<Stringinstances = state.getRecord().getListField(partition.stringify());
       String master = instances.get(0);
       if (!nodeMasterAssignmentMap.containsKey(master)) {
         nodeMasterAssignmentMap.put(masternew ArrayList<Integer>());
       }
       if (!combinedNodeSlaveAssignmentMap.containsKey(master)) {
         combinedNodeSlaveAssignmentMap.put(masternew TreeMap<StringList<Integer>>());
       }
       nodeMasterAssignmentMap.get(master).add(partitionIndex.get(partition));
       for (int i = 1; i < instances.size(); i++) {
         String instance = instances.get(i);
         Map<StringList<Integer>> slaveMap = combinedNodeSlaveAssignmentMap.get(master);
         if (!slaveMap.containsKey(instance)) {
           slaveMap.put(instancenew ArrayList<Integer>());
         }
         slaveMap.get(instance).add(partitionIndex.get(partition));
       }
     }
 
     Map<StringObjectresult = new TreeMap<StringObject>();
    result.put("PrimaryAssignmentMap"nodeMasterAssignmentMap);
    result.put("SecondaryAssignmentMap"combinedNodeSlaveAssignmentMap);
    result.put("replicas", Integer.parseInt(state.getReplicas()));
    result.put("partitions"new Integer(state.getRecord().getListFields().size()));
    result.put("reversePartitionIndex"reversePartitionIndex);
    return result;
  }
  public static String[] parseStates(String clusterNameStateModelDefinition stateModDef) {
    String[] result = new String[2];
    String masterStateValue = nullslaveStateValue = null;
    // StateModelDefinition def = new StateModelDefinition(stateModDef);
    List<StringstatePriorityList = stateModDef.getStatesPriorityList();
    for (String state : statePriorityList) {
      String count = stateModDef.getNumInstancesPerState(state);
      if (count.equals("1")) {
        if (masterStateValue != null) {
          throw new HelixException("Invalid or unsupported state model definition");
        }
        masterStateValue = state;
      } else if (count.equalsIgnoreCase("R")) {
        if (slaveStateValue != null) {
          throw new HelixException("Invalid or unsupported state model definition");
        }
        slaveStateValue = state;
      } else if (count.equalsIgnoreCase("N")) {
        if (!(masterStateValue == null && slaveStateValue == null)) {
          throw new HelixException("Invalid or unsupported state model definition");
        }
        masterStateValue = slaveStateValue = state;
      }
    }
    if (masterStateValue == null && slaveStateValue == null) {
      throw new HelixException("Invalid or unsupported state model definition");
    }
    if (masterStateValue == null) {
      masterStateValue = slaveStateValue;
    }
    result[0] = masterStateValue;
    result[1] = slaveStateValue;
    return result;
  }
New to GrepCode? Check out our FAQ X