Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.apache.helix.manager.zk;
  
  /*
   * 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;
 
 
   private static Logger LOG = Logger.getLogger(ZKHelixDataAccessor.class);
   private final String _clusterName;
   private final Builder _propertyKeyBuilder;
   private final GroupCommit _groupCommit = new GroupCommit();
 
   public ZKHelixDataAccessor(String clusterNameBaseDataAccessor<ZNRecordbaseDataAccessor) {
     this(clusterNamenullbaseDataAccessor);
   }
 
   public ZKHelixDataAccessor(String clusterNameInstanceType instanceType,
       BaseDataAccessor<ZNRecordbaseDataAccessor) {
      = clusterName;
      = instanceType;
      = baseDataAccessor;
   }
 
   @Override
   public <T extends HelixPropertyboolean createProperty(PropertyKey key, T value) {
     PropertyType type = key.getType();
     String path = key.getPath();
     int options = constructOptions(type);
     boolean success = false;
     switch (type) {
     case :
       if (value != null && value.isValid()) {
         success = .create(pathvalue.getRecord(), options);
       }
       break;
     default:
       success = .create(pathvalue == null ? null : value.getRecord(), options);
       break;
     }
     return success;
   }
 
   @Override
   public <T extends HelixPropertyboolean setProperty(PropertyKey key, T value) {
     PropertyType type = key.getType();
     if (!value.isValid()) {
       throw new HelixException("The ZNRecord for " + type + " is not valid.");
     }
 
    String path = key.getPath();
    int options = constructOptions(type);
    if (type.usePropertyTransferServer()) {
      if ( != null &&  != null) {
        ZNRecordUpdate update = new ZNRecordUpdate(path.value.getRecord());
        return true;
      }
    }
    boolean success = false;
    switch (type) {
    case :
    case :
      // check if bucketized
      if (value.getBucketSize() > 0) {
        // set parent node
        ZNRecord metaRecord = new ZNRecord(value.getId());
        metaRecord.setSimpleFields(value.getRecord().getSimpleFields());
        success = .set(pathmetaRecordoptions);
        if (success) {
          ZNRecordBucketizer bucketizer = new ZNRecordBucketizer(value.getBucketSize());
          Map<StringZNRecordmap = bucketizer.bucketize(value.getRecord());
          List<Stringpaths = new ArrayList<String>();
          List<ZNRecordbucketizedRecords = new ArrayList<ZNRecord>();
          for (String bucketName : map.keySet()) {
            paths.add(path + "/" + bucketName);
            bucketizedRecords.add(map.get(bucketName));
          }
          // TODO: set success accordingly
          .setChildren(pathsbucketizedRecordsoptions);
        }
      } else {
        success = .set(pathvalue.getRecord(), options);
      }
      break;
    default:
      success = .set(pathvalue.getRecord(), options);
      break;
    }
    return success;
  }
  public <T extends HelixPropertyboolean updateProperty(PropertyKey key, T value) {
    PropertyType type = key.getType();
    String path = key.getPath();
    int options = constructOptions(type);
    boolean success = false;
    switch (type) {
    case :
      success = .commit(optionspathvalue.getRecord());
      break;
    default:
      if (type.usePropertyTransferServer()) {
        if ( != null &&  != null) {
          ZNRecordUpdate update = new ZNRecordUpdate(path.value.getRecord());
          return true;
        } else {
          if (.isTraceEnabled()) {
            .trace("getPropertyTransferUrl is null, skip updating the value");
          }
          return true;
        }
      }
      success = .update(pathnew ZNRecordUpdater(value.getRecord()), options);
      break;
    }
    return success;
  }
  public <T extends HelixPropertyList<T> getProperty(List<PropertyKeykeys) {
    if (keys == null || keys.size() == 0) {
      return Collections.emptyList();
    }
    List<T> childValues = new ArrayList<T>();
    // read all records
    List<Stringpaths = new ArrayList<String>();
    for (PropertyKey key : keys) {
      paths.add(key.getPath());
    }
    List<ZNRecordchildren = .get(pathsnull, 0);
    // check if bucketized
    for (int i = 0; i < keys.size(); i++) {
      PropertyKey key = keys.get(i);
      ZNRecord record = children.get(i);
      PropertyType type = key.getType();
      String path = key.getPath();
      int options = constructOptions(type);
      // ZNRecord record = null;
      switch (type) {
      case :
      case :
      case :
        // check if bucketized
        if (record != null) {
          HelixProperty property = new HelixProperty(record);
          int bucketSize = property.getBucketSize();
          if (bucketSize > 0) {
            List<ZNRecordchildRecords = .getChildren(pathnulloptions);
            ZNRecord assembledRecord = new ZNRecordAssembler().assemble(childRecords);
            // merge with parent node value
            if (assembledRecord != null) {
              record.getSimpleFields().putAll(assembledRecord.getSimpleFields());
              record.getListFields().putAll(assembledRecord.getListFields());
              record.getMapFields().putAll(assembledRecord.getMapFields());
            }
          }
        }
        break;
      default:
        break;
      }
      @SuppressWarnings("unchecked")
      T t = (T) HelixProperty.convertToTypedInstance(key.getTypeClass(), record);
      childValues.add(t);
    }
    return childValues;
  }
  public <T extends HelixProperty> T getProperty(PropertyKey key) {
    PropertyType type = key.getType();
    String path = key.getPath();
    int options = constructOptions(type);
    ZNRecord record = null;
    try {
      Stat stat = new Stat();
      record = .get(pathstatoptions);
      if (record != null) {
        record.setCreationTime(stat.getCtime());
        record.setModifiedTime(stat.getMtime());
      }
    } catch (ZkNoNodeException e) {
      // OK
    }
    switch (type) {
    case :
    case :
    case :
      // check if bucketized
      if (record != null) {
        HelixProperty property = new HelixProperty(record);
        int bucketSize = property.getBucketSize();
        if (bucketSize > 0) {
          List<ZNRecordchildRecords = .getChildren(pathnulloptions);
          ZNRecord assembledRecord = new ZNRecordAssembler().assemble(childRecords);
          // merge with parent node value
          if (assembledRecord != null) {
            record.getSimpleFields().putAll(assembledRecord.getSimpleFields());
            record.getListFields().putAll(assembledRecord.getListFields());
            record.getMapFields().putAll(assembledRecord.getMapFields());
          }
        }
      }
      break;
    default:
      break;
    }
    @SuppressWarnings("unchecked")
    T t = (T) HelixProperty.convertToTypedInstance(key.getTypeClass(), record);
    return t;
  }
  public boolean removeProperty(PropertyKey key) {
    PropertyType type = key.getType();
    String path = key.getPath();
    int options = constructOptions(type);
    return .remove(pathoptions);
  }
  public List<StringgetChildNames(PropertyKey key) {
    PropertyType type = key.getType();
    String parentPath = key.getPath();
    int options = constructOptions(type);
    List<StringchildNames = .getChildNames(parentPathoptions);
    if (childNames == null) {
      childNames = Collections.emptyList();
    }
    return childNames;
  }
  public <T extends HelixPropertyList<T> getChildValues(PropertyKey key) {
    PropertyType type = key.getType();
    String parentPath = key.getPath();
    int options = constructOptions(type);
    List<T> childValues = new ArrayList<T>();
    List<ZNRecordchildren = .getChildren(parentPathnulloptions);
    if (children != null) {
      for (ZNRecord record : children) {
        switch (type) {
        case :
        case :
        case :
          if (record != null) {
            HelixProperty property = new HelixProperty(record);
            int bucketSize = property.getBucketSize();
            if (bucketSize > 0) {
              // TODO: fix this if record.id != pathName
              String childPath = parentPath + "/" + record.getId();
              List<ZNRecordchildRecords = .getChildren(childPathnulloptions);
              ZNRecord assembledRecord = new ZNRecordAssembler().assemble(childRecords);
              // merge with parent node value
              if (assembledRecord != null) {
                record.getSimpleFields().putAll(assembledRecord.getSimpleFields());
                record.getListFields().putAll(assembledRecord.getListFields());
                record.getMapFields().putAll(assembledRecord.getMapFields());
              }
            }
          }
          break;
        default:
          break;
        }
        if (record != null) {
          @SuppressWarnings("unchecked")
          T t = (T) HelixProperty.convertToTypedInstance(key.getTypeClass(), record);
          childValues.add(t);
        }
      }
    }
    return childValues;
  }
  public <T extends HelixPropertyMap<String, T> getChildValuesMap(PropertyKey key) {
    PropertyType type = key.getType();
    String parentPath = key.getPath();
    int options = constructOptions(type);
    List<T> children = getChildValues(key);
    Map<String, T> childValuesMap = new HashMap<String, T>();
    for (T t : children) {
      childValuesMap.put(t.getRecord().getId(), t);
    }
    return childValuesMap;
  }
  public Builder keyBuilder() {
    return ;
  }
  private int constructOptions(PropertyType type) {
    int options = 0;
    if (type.isPersistent()) {
      options = options | .;
    } else {
      options = options | .;
    }
    return options;
  }
  public <T extends HelixPropertyboolean[] createChildren(List<PropertyKeykeysList<T> children) {
    // TODO: add validation
    int options = -1;
    List<Stringpaths = new ArrayList<String>();
    List<ZNRecordrecords = new ArrayList<ZNRecord>();
    for (int i = 0; i < keys.size(); i++) {
      PropertyKey key = keys.get(i);
      PropertyType type = key.getType();
      String path = key.getPath();
      paths.add(path);
      HelixProperty value = children.get(i);
      records.add(value.getRecord());
      options = constructOptions(type);
    }
    return .createChildren(pathsrecordsoptions);
  }
  public <T extends HelixPropertyboolean[] setChildren(List<PropertyKeykeysList<T> children) {
    int options = -1;
    List<Stringpaths = new ArrayList<String>();
    List<ZNRecordrecords = new ArrayList<ZNRecord>();
    List<List<String>> bucketizedPaths =
        new ArrayList<List<String>>(Collections.<List<String>> nCopies(keys.size(), null));
    List<List<ZNRecord>> bucketizedRecords =
        new ArrayList<List<ZNRecord>>(Collections.<List<ZNRecord>> nCopies(keys.size(), null));
    for (int i = 0; i < keys.size(); i++) {
      PropertyKey key = keys.get(i);
      PropertyType type = key.getType();
      String path = key.getPath();
      paths.add(path);
      options = constructOptions(type);
      HelixProperty value = children.get(i);
      switch (type) {
      case :
        if (value.getBucketSize() == 0) {
          records.add(value.getRecord());
        } else {
          .remove(pathoptions);
          ZNRecord metaRecord = new ZNRecord(value.getId());
          metaRecord.setSimpleFields(value.getRecord().getSimpleFields());
          records.add(metaRecord);
          ZNRecordBucketizer bucketizer = new ZNRecordBucketizer(value.getBucketSize());
          Map<StringZNRecordmap = bucketizer.bucketize(value.getRecord());
          List<StringchildBucketizedPaths = new ArrayList<String>();
          List<ZNRecordchildBucketizedRecords = new ArrayList<ZNRecord>();
          for (String bucketName : map.keySet()) {
            childBucketizedPaths.add(path + "/" + bucketName);
            childBucketizedRecords.add(map.get(bucketName));
          }
          bucketizedPaths.set(ichildBucketizedPaths);
          bucketizedRecords.set(ichildBucketizedRecords);
        }
        break;
      case :
        if (value.isValid()) {
          records.add(value.getRecord());
        }
        break;
      default:
        records.add(value.getRecord());
        break;
      }
    }
    // set non-bucketized nodes or parent nodes of bucketized nodes
    boolean success[] = .setChildren(pathsrecordsoptions);
    // set bucketized nodes
    List<StringallBucketizedPaths = new ArrayList<String>();
    List<ZNRecordallBucketizedRecords = new ArrayList<ZNRecord>();
    for (int i = 0; i < keys.size(); i++) {
      if (success[i] && bucketizedPaths.get(i) != null) {
        allBucketizedPaths.addAll(bucketizedPaths.get(i));
        allBucketizedRecords.addAll(bucketizedRecords.get(i));
      }
    }
    // TODO: set success accordingly
    .setChildren(allBucketizedPathsallBucketizedRecordsoptions);
    return success;
  }
    return ;
  }
  public <T extends HelixPropertyboolean[] updateChildren(List<Stringpaths,
      List<DataUpdater<ZNRecord>> updatersint options) {
    return .updateChildren(pathsupdatersoptions);
  }
  public void shutdown() {
    if ( != null) {
    }
  }
  public void onControllerChange(NotificationContext changeContext) {
    .info("Controller has changed");
    if ( == null) {
      if ( != null && .length() > 0) {
        .info("Creating ZkPropertyTransferClient as we get url " + );
         =
      }
    }
  }
    try {
      if (leader != null) {
         = leader.getWebserviceUrl();
        .info("_zkPropertyTransferSvcUrl : " +  + " Controller "
            + leader.getInstanceName());
      } else {
         = null;
      }
    } catch (Exception e) {
      // LOG.error("", e);
       = null;
    }
  }
New to GrepCode? Check out our FAQ X