hadoop PathLocation 源码

haddop PathLocation 代码

文件路径：/hadoop-hdfs-project/hadoop-hdfs-rbf/src/main/java/org/apache/hadoop/hdfs/server/federation/resolver/PathLocation.java

/**
 * 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.
 */
package org.apache.hadoop.hdfs.server.federation.resolver;

import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import org.apache.hadoop.hdfs.server.federation.resolver.order.DestinationOrder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * A map of the properties and target destinations (name space + path) for
 * a path in the global/federated name space.
 * This data is generated from the @see MountTable records.
 */
public class PathLocation {

  private static final Logger LOG = LoggerFactory.getLogger(PathLocation.class);


  /** Source path in global namespace. */
  private final String sourcePath;

  /** Remote paths in the target name spaces. */
  private final List<RemoteLocation> destinations;
  /** Order for the destinations. */
  private final DestinationOrder destOrder;


  /**
   * Create a new PathLocation.
   *
   * @param source Source path in the global name space.
   * @param dest Destinations of the mount table entry.
   * @param order Order of the locations.
   */
  public PathLocation(
      String source, List<RemoteLocation> dest, DestinationOrder order) {
    this.sourcePath = source;
    this.destinations = Collections.unmodifiableList(dest);
    this.destOrder = order;
  }

  /**
   * Create a new PathLocation with default HASH order.
   *
   * @param source Source path in the global name space.
   * @param dest Destinations of the mount table entry.
   */
  public PathLocation(String source, List<RemoteLocation> dest) {
    this(source, dest, DestinationOrder.HASH);
  }

  /**
   * Create a path location from another path.
   *
   * @param other Other path location to copy from.
   */
  public PathLocation(final PathLocation other) {
    this.sourcePath = other.sourcePath;
    this.destinations = Collections.unmodifiableList(other.destinations);
    this.destOrder = other.destOrder;
  }

  /**
   * Create a path location from another path with the destinations sorted.
   *
   * @param other Other path location to copy from.
   * @param firstNsId Identifier of the namespace to place first.
   */
  @Deprecated
  public PathLocation(PathLocation other, String firstNsId) {
    this.sourcePath = other.sourcePath;
    this.destOrder = other.destOrder;
    this.destinations = orderedNamespaces(other.destinations, firstNsId);
  }

  /**
   * Return a path location with the prioritized destinations based on
   * the current path location.
   *
   * @param base The base path location we'd like to prioritize on.
   * @param firstNsId Identifier of the namespace to place first.
   */
  public static PathLocation prioritizeDestination(
      PathLocation base, String firstNsId) {
    List<RemoteLocation> prioritizedDestinations = orderedNamespaces(
        base.destinations, firstNsId);
    return new PathLocation(base.sourcePath, prioritizedDestinations,
        base.destOrder);
  }

  /**
   * Prioritize a location/destination by its name space/nameserviceId.
   * This destination might be used by other threads, so the source is not
   * modifiable.
   *
   * @param original List of destinations to order.
   * @param nsId The name space/nameserviceID to prioritize.
   * @return Prioritized list of detinations that cannot be modified.
   */
  private static List<RemoteLocation> orderedNamespaces(
      final List<RemoteLocation> original, final String nsId) {
    if (original.size() <= 1) {
      return original;
    }

    LinkedList<RemoteLocation> newDestinations = new LinkedList<>();
    boolean found = false;
    for (RemoteLocation dest : original) {
      if (dest.getNameserviceId().equals(nsId)) {
        found = true;
        newDestinations.addFirst(dest);
      } else {
        newDestinations.add(dest);
      }
    }

    if (!found) {
      LOG.debug("Cannot find location with namespace {} in {}",
          nsId, original);
    }
    return Collections.unmodifiableList(newDestinations);
  }

  /**
   * Get the source path in the global namespace for this path location.
   *
   * @return The path in the global namespace.
   */
  public String getSourcePath() {
    return this.sourcePath;
  }

  /**
   * Get the subclusters defined for the destinations.
   *
   * @return Set containing the subclusters.
   */
  public Set<String> getNamespaces() {
    Set<String> namespaces = new HashSet<>();
    List<RemoteLocation> locations = this.getDestinations();
    for (RemoteLocation location : locations) {
      String nsId = location.getNameserviceId();
      namespaces.add(nsId);
    }
    return namespaces;
  }

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder();
    for (RemoteLocation destination : this.destinations) {
      String nsId = destination.getNameserviceId();
      String path = destination.getDest();
      if (sb.length() > 0) {
        sb.append(",");
      }
      sb.append(nsId + "->" + path);
    }
    if (this.destinations.size() > 1) {
      sb.append(" [")
          .append(this.destOrder.toString())
          .append("]");
    }
    return sb.toString();
  }

  /**
   * Check if this location supports multiple clusters/paths.
   *
   * @return If it has multiple destinations.
   */
  public boolean hasMultipleDestinations() {
    return this.destinations.size() > 1;
  }

  /**
   * Get the list of locations found in the mount table.
   * The first result is the highest priority path.
   *
   * @return List of remote locations.
   */
  public List<RemoteLocation> getDestinations() {
    return Collections.unmodifiableList(this.destinations);
  }

  /**
   * Get the order for the destinations.
   *
   * @return Order for the destinations.
   */
  public DestinationOrder getDestinationOrder() {
    return this.destOrder;
  }

  /**
   * Get the default or highest priority location.
   *
   * @return The default location.
   */
  public RemoteLocation getDefaultLocation() {
    if (destinations.isEmpty() || destinations.get(0).getDest() == null) {
      throw new UnsupportedOperationException(
          "Unsupported path " + sourcePath + " please check mount table");
    }
    return destinations.get(0);
  }
}

相关信息

hadoop 源码目录

相关文章

hadoop ActiveNamenodeResolver 源码

hadoop FederationNamenodeContext 源码

hadoop FederationNamenodeServiceState 源码

hadoop FederationNamespaceInfo 源码

hadoop FileSubclusterResolver 源码

hadoop MembershipNamenodeResolver 源码

hadoop MountTableManager 源码

hadoop MountTableResolver 源码

hadoop MultipleDestinationMountTableResolver 源码

hadoop NamenodePriorityComparator 源码