Java Code Examples for org.apache.helix.PropertyKey#getPath()

@Override
public <T extends HelixProperty> boolean updateProperty(PropertyKey key, DataUpdater<ZNRecord> updater, T value) {
  PropertyType type = key.getType();
  String path = key.getPath();
  int options = constructOptions(type);

  boolean success = false;
  switch (type) {
  case CURRENTSTATES:
    success = _groupCommit.commit(_baseDataAccessor, options, path, value.getRecord(), true);
    break;
  case STATUSUPDATES:
    if (LOG.isTraceEnabled()) {
      LOG.trace("Update status. path: " + key.getPath() + ", record: " + value.getRecord());
    }
    break;
  default:
    success = _baseDataAccessor.update(path, updater, options);
    break;
  }
  return success;
}
 

@Override
public HelixProperty.Stat getPropertyStat(PropertyKey key) {
  PropertyType type = key.getType();
  String path = key.getPath();
  int options = constructOptions(type);
  try {
    Stat stat = _baseDataAccessor.getStat(path, options);
    if (stat != null) {
      return new HelixProperty.Stat(stat.getVersion(), stat.getCtime(), stat.getMtime(), stat.getEphemeralOwner());
    }
  } catch (ZkNoNodeException e) {

  }

  return null;
}
 

@Override
public <T extends HelixProperty> boolean[] createChildren(List<PropertyKey> keys, List<T> children) {
  // TODO: add validation
  int options = -1;
  List<String> paths = new ArrayList<String>();
  List<ZNRecord> records = 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 _baseDataAccessor.createChildren(paths, records, options);
}
 

public static Map<String, String> readZkChildrenAsBytesMap(ZkClient zkclient, PropertyKey propertyKey) {
  BaseDataAccessor<byte[]> baseAccessor = new ZkBaseDataAccessor<byte[]>(zkclient);
  String parentPath = propertyKey.getPath();
  List<String> childNames = baseAccessor.getChildNames(parentPath, 0);
  if (childNames == null) {
    return null;
  }
  List<String> paths = new ArrayList<String>();
  for (String childName : childNames) {
    paths.add(parentPath + "/" + childName);
  }
  List<byte[]> values = baseAccessor.get(paths, null, 0);
  Map<String, String> ret = new HashMap<String, String>();
  for (int i = 0; i < childNames.size(); i++) {
    ret.put(childNames.get(i), new String(values.get(i)));
  }
  return ret;
}
 

public CallbackHandler(HelixManager manager, RealmAwareZkClient client, PropertyKey propertyKey,
    Object listener, EventType[] eventTypes, ChangeType changeType,
    HelixCallbackMonitor monitor) {
  if (listener == null) {
    throw new HelixException("listener could not be null");
  }

  if (monitor != null && !monitor.getChangeType().equals(changeType)) {
    throw new HelixException("The specified callback monitor is for different change type: "
        + monitor.getChangeType().name());
  }

  _manager = manager;
  _accessor = manager.getHelixDataAccessor();
  _zkClient = client;
  _propertyKey = propertyKey;
  _path = propertyKey.getPath();
  _listener = listener;
  _eventTypes = new HashSet<>(Arrays.asList(eventTypes));
  _changeType = changeType;
  _lastNotificationTimeStamp = new AtomicLong(System.nanoTime());
  _monitor = monitor;

  if (_changeType == MESSAGE || _changeType == MESSAGES_CONTROLLER || _changeType == CONTROLLER) {
    _watchChild = false;
  } else {
    _watchChild = true;
  }

  parseListenerProperties();

  init();
}
 

@Override
public boolean removeProperty(PropertyKey key) {
  PropertyType type = key.getType();
  String path = key.getPath();
  int options = constructOptions(type);

  return _baseDataAccessor.remove(path, options);
}
 

@Override
public List<String> getChildNames(PropertyKey key) {
  PropertyType type = key.getType();
  String parentPath = key.getPath();
  int options = constructOptions(type);
  List<String> childNames = _baseDataAccessor.getChildNames(parentPath, options);
  if (childNames == null) {
    childNames = Collections.emptyList();
  }
  return childNames;
}
 

@Override
public <T extends HelixProperty> Map<String, T> getChildValuesMap(PropertyKey key,
    boolean throwException) {
  PropertyType type = key.getType();
  String parentPath = key.getPath();
  int options = constructOptions(type);
  List<T> children = getChildValues(key, throwException);
  Map<String, T> childValuesMap = new HashMap<String, T>();
  for (T t : children) {
    childValuesMap.put(t.getRecord().getId(), t);
  }
  return childValuesMap;
}
 

public static String readZkAsBytes(ZkClient zkclient, PropertyKey propertyKey) {
  try {
    byte[] bytes = zkclient.readData(propertyKey.getPath());
    return new String(bytes);
  } catch (Exception e) {
    String errorMessage = "Exception occurred when reading data from path: " + propertyKey.getPath();
    LOG.error(errorMessage, e);
    throw new HelixException(errorMessage, e);
  }
}
 

@Override
public <T extends HelixProperty> boolean setProperty(PropertyKey key, T value) {
  PropertyType type = key.getType();
  if (!value.isValid()) {
    throw new HelixMetaDataAccessException("The ZNRecord for " + type + " is not valid.");
  }

  String path = key.getPath();
  int options = constructOptions(type);

  boolean success = false;
  switch (type) {
  case IDEALSTATES:
  case EXTERNALVIEW:
    // check if bucketized
    if (value.getBucketSize() > 0) {
      // set parent node
      ZNRecord metaRecord = new ZNRecord(value.getId());
      metaRecord.setSimpleFields(value.getRecord().getSimpleFields());
      success = _baseDataAccessor.set(path, metaRecord, options);
      if (success) {
        ZNRecordBucketizer bucketizer = new ZNRecordBucketizer(value.getBucketSize());

        Map<String, ZNRecord> map = bucketizer.bucketize(value.getRecord());
        List<String> paths = new ArrayList<String>();
        List<ZNRecord> bucketizedRecords = new ArrayList<ZNRecord>();
        for (String bucketName : map.keySet()) {
          paths.add(path + "/" + bucketName);
          bucketizedRecords.add(map.get(bucketName));
        }

        // TODO: set success accordingly
        _baseDataAccessor.setChildren(paths, bucketizedRecords, options);
      }
    } else {
      success = _baseDataAccessor.set(path, value.getRecord(), options);
    }
    break;
  default:
    success = _baseDataAccessor.set(path, value.getRecord(), options);
    break;
  }
  return success;
}
 

@Override
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 = _baseDataAccessor.get(path, stat, options);
    if (record != null) {
      record.setCreationTime(stat.getCtime());
      record.setModifiedTime(stat.getMtime());
      record.setVersion(stat.getVersion());
      record.setEphemeralOwner(stat.getEphemeralOwner());
    }
  } catch (ZkNoNodeException e) {
    // OK
  }

  switch (type) {
  case CURRENTSTATES:
  case IDEALSTATES:
  case EXTERNALVIEW:
    // check if bucketized
    if (record != null) {
      HelixProperty property = new HelixProperty(record);

      int bucketSize = property.getBucketSize();
      if (bucketSize > 0) {
        // @see HELIX-574
        // clean up list and map fields in case we write to parent node by mistake
        property.getRecord().getMapFields().clear();
        property.getRecord().getListFields().clear();

        List<ZNRecord> childRecords = _baseDataAccessor.getChildren(path, null, options, 0, 0);
        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;
}
 

@Override
public <T extends HelixProperty> List<T> getChildValues(PropertyKey key, boolean throwException) {
  PropertyType type = key.getType();
  String parentPath = key.getPath();
  int options = constructOptions(type);
  List<T> childValues = new ArrayList<T>();
  List<ZNRecord> children;
  if (throwException) {
    children = _baseDataAccessor.getChildren(parentPath, null, options, 1, 0);
  } else {
    children = _baseDataAccessor.getChildren(parentPath, null, options);
  }
  if (children != null) {
    for (ZNRecord record : children) {
      switch (type) {
      case CURRENTSTATES:
      case IDEALSTATES:
      case EXTERNALVIEW:
        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<ZNRecord> childRecords;
            if (throwException) {
              childRecords = _baseDataAccessor.getChildren(childPath, null, options, 1, 0);
            } else {
              childRecords = _baseDataAccessor.getChildren(childPath, null, options);
            }
            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;
}
 

@Override
public <T extends HelixProperty> boolean[] setChildren(List<PropertyKey> keys, List<T> children) {
  int options = -1;
  List<String> paths = new ArrayList<String>();
  List<ZNRecord> records = 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 EXTERNALVIEW:
      if (value.getBucketSize() == 0) {
        records.add(value.getRecord());
      } else {

        ZNRecord metaRecord = new ZNRecord(value.getId());
        metaRecord.setSimpleFields(value.getRecord().getSimpleFields());
        records.add(metaRecord);

        ZNRecordBucketizer bucketizer = new ZNRecordBucketizer(value.getBucketSize());

        Map<String, ZNRecord> map = bucketizer.bucketize(value.getRecord());
        List<String> childBucketizedPaths = new ArrayList<String>();
        List<ZNRecord> childBucketizedRecords = new ArrayList<ZNRecord>();
        for (String bucketName : map.keySet()) {
          childBucketizedPaths.add(path + "/" + bucketName);
          childBucketizedRecords.add(map.get(bucketName));
        }
        bucketizedPaths.set(i, childBucketizedPaths);
        bucketizedRecords.set(i, childBucketizedRecords);
      }
      break;
    case STATEMODELDEFS:
      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[] = _baseDataAccessor.setChildren(paths, records, options);

  // set bucketized nodes
  List<String> allBucketizedPaths = new ArrayList<String>();
  List<ZNRecord> allBucketizedRecords = 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
  _baseDataAccessor.setChildren(allBucketizedPaths, allBucketizedRecords, options);

  return success;
}