* 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.

*/

* DFSClient can connect to a Hadoop Filesystem and

* perform basic file tasks.  It uses the ClientProtocol

* to communicate with a NameNode daemon, and connects

* directly to DataNodes to read/write block data.

*

* Hadoop DFS users should obtain an instance of

* DistributedFileSystem, which uses DFSClient to handle

* filesystem tasks.

*

********************************************************/

  public static final Log LOG = LogFactory.getLog(DFSClient.class);

  public static final int MAX_BLOCK_ACQUIRE_FAILURES = 3;

  static final int TCP_WINDOW_SIZE = 128 * 1024; // 128 KB

  static byte[] emptyByteArray = new byte[0];

 

  public static final String DFS_CLIENT_SOCKET_CACHE_CAPACITY_KEY =

      "dfs.client.socketcache.capacity";

  public static final int DFS_CLIENT_SOCKET_CACHE_CAPACITY_DEFAULT = 16;

 

  public static final String DFS_CLIENT_CACHED_CONN_RETRY_KEY =

      "dfs.client.cached.conn.retry";

  public static final int DFS_CLIENT_CACHED_CONN_RETRY_DEFAULT = 3;

 

  public ClientProtocol namenode;

  private ClientProtocol rpcNamenode;

  // Namenode proxy that supports method-based compatibility

  public ProtocolProxy<ClientProtocol> namenodeProtocolProxy = null;

  public Object namenodeProxySyncObj = new Object();

  final UserGroupInformation ugi;

  volatile boolean clientRunning = true;

  static Random r = new Random();

  final String clientName;

  final LeaseChecker leasechecker;

  Configuration conf;

  long defaultBlockSize;

  private short defaultReplication;

  final private int preferredPacketVersion;

  SocketFactory socketFactory;

  int namenodeRPCSocketTimeout;

  int socketTimeout;

  int socketReadExtentionTimeout;

  int datanodeWriteTimeout;

  int datanodeWriteExtentionTimeout;

  int timeoutValue;  // read timeout for the socket

  final int writePacketSize;

  final long bytesToCheckReadSpeed;

  final long minReadSpeedBps;

  final boolean enableThrowForSlow;

  final FileSystem.Statistics stats;

  int maxBlockAcquireFailures;

  final int hdfsTimeout;    // timeout value for a DFS operation.

  // The amount of time to wait before aborting a close file.

  final SocketCache socketCache;

 

  private final long closeFileTimeout;

  private long namenodeVersion = ClientProtocol.versionID;

  DFSClientMetrics metrics;

  protected Integer dataTransferVersion = -1;

  protected volatile int namespaceId = 0;

  boolean shortCircuitLocalReads = false;

  boolean shortcircuitDisableWhenFail = true;

  final InetAddress localHost;

  InetSocketAddress nameNodeAddr;

  private DatanodeInfo pseuDatanodeInfoForLocalhost;

  private String localhostNetworkLocation = null;

  DNSToSwitchMapping dnsToSwitchMapping = null;

  int ipTosValue = NetUtils.NOT_SET_IP_TOS;

 

  final BlockLocationRenewal blockLocationRenewal;

  private final static ThreadLocal<DFSReadProfilingData> dfsReadContext =

      new ThreadLocal<DFSReadProfilingData>();

  private final static ThreadLocal<DFSWriteProfilingData> profileForNextOutputStream =

      new ThreadLocal<DFSWriteProfilingData>();

 

  protected long quorumReadThresholdMillis;

  public DFSQuorumReadMetrics quorumReadMetrics;

 

  private FileStatusCache fileStatusCache;

 

  public void setQuorumReadTimeout(long timeoutMillis) {

    this.quorumReadThresholdMillis = timeoutMillis;

  }

 

  public volatile boolean allowParallelReads = false;

 

  private final DistributedFileSystem dfs;

  public void enableParallelReads() {

    allowParallelReads = true;

  }

  public void disableParallelReads() {

    allowParallelReads = false;

  }

 

  protected ThreadPoolExecutor parallelReadsThreadPool = null;

  public void setNumParallelThreadsForReads(int num) {

    if (this.parallelReadsThreadPool == null) {

      this.parallelReadsThreadPool = new ThreadPoolExecutor(1,

          num, 60, TimeUnit.SECONDS,

        new SynchronousQueue<Runnable>(),

        new DaemonThreadFactory("dfsclient-reader-thread-"),

        new ThreadPoolExecutor.CallerRunsPolicy() {

       

          public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

            // increment metrics

            LOG.debug("Execution rejected, Executing in current thread");

            quorumReadMetrics.incParallelReadOpsInCurThread();

           

            // will run in the current thread

            super.rejectedExecution(r, e);

          }

         

      });

      parallelReadsThreadPool.allowCoreThreadTimeOut(true);

    } else {

      this.parallelReadsThreadPool.setMaximumPoolSize(num);

    }

  }

 

  public static void startReadProfiling() {

    dfsReadContext.set(new DFSReadProfilingData());

  }

 

  public static void stopReadProfiling() {

    dfsReadContext.remove();

  }

 

  public static DFSReadProfilingData getDFSReadProfilingData() {

    return dfsReadContext.get();

  }

  public static void setProfileDataForNextOutputStream(

      DFSWriteProfilingData profile) {

    profileForNextOutputStream.set(profile);

  }

  public static DFSWriteProfilingData getAndResetProfileDataForNextOutputStream() {

    DFSWriteProfilingData profile = profileForNextOutputStream.get();

    profileForNextOutputStream.remove();

    return profile;

  }

 

  /**

   * This variable tracks the number of failures for each thread of

   * dfs input stream since the start of the most recent user-facing operation.

   * That is to say, it should be reset

   * whenever the user makes a call on this stream, and if at any point

   * during the retry logic, the failure count exceeds a threshold,

   * the errors will be thrown back to the operation.

   *

   * Specifically this counts the number of times the client has gone

   * back to the namenode to get a new list of block locations, and is

   * capped at maxBlockAcquireFailures

   *

   */

  static ThreadLocal<Integer> dfsInputStreamfailures =

    new ThreadLocal<Integer>();

  /**

   * The locking hierarchy is to first acquire lock on DFSClient object, followed by

   * lock on leasechecker, followed by lock on an individual DFSOutputStream.

   */

  public static ClientProtocol createNamenode(Configuration conf) throws IOException {

    return createNamenode(NameNode.getClientProtocolAddress(conf), conf);

  }

  public static ClientProtocol createNamenode( InetSocketAddress nameNodeAddr,

      Configuration conf) throws IOException {

    try {

      return createNamenode(

          createRPCNamenode(nameNodeAddr, conf,

              UserGroupInformation.getUGI(conf),

              conf.getInt(DFS_CLIENT_NAMENODE_SOCKET_TIMEOUT, 0)).getProxy(),

          conf);

    } catch (LoginException e) {

      throw (IOException)(new IOException().initCause(e));

    }

  }

 

  /**

   * Create a NameNode proxy for the client if the client and NameNode

   * are compatible

   *

   * @param nameNodeAddr NameNode address

   * @param conf configuration

   * @param ugi ticket

   * @return a NameNode proxy that's compatible with the client

   */

  private void createRPCNamenodeIfCompatible(

      InetSocketAddress nameNodeAddr,

      Configuration conf,

      UserGroupInformation ugi) throws IOException {

    try {

      this.namenodeProtocolProxy = createRPCNamenode(nameNodeAddr, conf, ugi,

          namenodeRPCSocketTimeout);

      this.rpcNamenode = namenodeProtocolProxy.getProxy();

    } catch (RPC.VersionMismatch e) {

      long clientVersion = e.getClientVersion();

      namenodeVersion = e.getServerVersion();

      if (clientVersion > namenodeVersion &&

          !ProtocolCompatible.isCompatibleClientProtocol(

              clientVersion, namenodeVersion)) {

        throw new RPC.VersionIncompatible(

            ClientProtocol.class.getName(), clientVersion, namenodeVersion);

      }

      this.rpcNamenode = (ClientProtocol)e.getProxy();

    }

  }

  public static ProtocolProxy<ClientProtocol> createRPCNamenode(

      Configuration conf) throws IOException {

    try {

      return createRPCNamenode(NameNode.getClientProtocolAddress(conf), conf,

          UserGroupInformation.getUGI(conf),

          conf.getInt(DFS_CLIENT_NAMENODE_SOCKET_TIMEOUT, 0));

    } catch (LoginException e) {

      throw new IOException(e);

    }  

  }

  public static ProtocolProxy<ClientProtocol> createRPCNamenode(InetSocketAddress nameNodeAddr,

      Configuration conf, UserGroupInformation ugi, int rpcTimeout)

    throws IOException {

    return RPC.getProtocolProxy(ClientProtocol.class,

        ClientProtocol.versionID, nameNodeAddr, ugi, conf,

        NetUtils.getSocketFactory(conf, ClientProtocol.class), rpcTimeout);

  }

  static ClientProtocol createNamenode(ClientProtocol rpcNamenode,

      Configuration conf)

    throws IOException {

    long sleepTime = conf.getLong("dfs.client.rpc.retry.sleep",

        LEASE_SOFTLIMIT_PERIOD);

    RetryPolicy createPolicy = RetryPolicies.retryUpToMaximumCountWithFixedSleep(

        5, sleepTime, TimeUnit.MILLISECONDS);

    Map<Class<? extends Exception>,RetryPolicy> remoteExceptionToPolicyMap =

      new HashMap<Class<? extends Exception>, RetryPolicy>();

    remoteExceptionToPolicyMap.put(AlreadyBeingCreatedException.class, createPolicy);

    Map<Class<? extends Exception>,RetryPolicy> exceptionToPolicyMap =

      new HashMap<Class<? extends Exception>, RetryPolicy>();

    exceptionToPolicyMap.put(RemoteException.class,

        RetryPolicies.retryByRemoteException(

            RetryPolicies.TRY_ONCE_THEN_FAIL, remoteExceptionToPolicyMap));

    RetryPolicy methodPolicy = RetryPolicies.retryByException(

        RetryPolicies.TRY_ONCE_THEN_FAIL, exceptionToPolicyMap);

    Map<String,RetryPolicy> methodNameToPolicyMap = new HashMap<String,RetryPolicy>();

    methodNameToPolicyMap.put("create", methodPolicy);

    return (ClientProtocol) RetryProxy.create(ClientProtocol.class,

        rpcNamenode, methodNameToPolicyMap);

  }

  public static ClientDatanodeProtocol createClientDatanodeProtocolProxy(

      DatanodeID datanodeid, Configuration conf, int socketTimeout)

      throws IOException {

    return createClientDNProtocolProxy(datanodeid, conf, socketTimeout).getProxy();

  }

 

  static ProtocolProxy<ClientDatanodeProtocol> createClientDNProtocolProxy (

      DatanodeID datanodeid, Configuration conf, int socketTimeout)

      throws IOException {

    InetSocketAddress addr = NetUtils.createSocketAddr(

      datanodeid.getHost() + ":" + datanodeid.getIpcPort());

    if (ClientDatanodeProtocol.LOG.isDebugEnabled()) {

      ClientDatanodeProtocol.LOG.info("ClientDatanodeProtocol addr=" + addr);

    }

    UserGroupInformation ugi;

    try {

      ugi = UserGroupInformation.login(conf);

    } catch (LoginException le) {

      throw new RuntimeException("Couldn't login!");

    }

    return RPC.getProtocolProxy(ClientDatanodeProtocol.class,

        ClientDatanodeProtocol.versionID, addr, ugi, conf,

        NetUtils.getDefaultSocketFactory(conf), socketTimeout);

  }

  /**

   * Same as this(NameNode.getClientProtocolAddress(conf), conf);

   * @see #DFSClient(InetSocketAddress, Configuration)

   */

  public DFSClient(Configuration conf) throws IOException {

    this(NameNode.getClientProtocolAddress(conf), conf);

  }

  /**

   * Same as this(nameNodeAddr, conf, null);

   * @see #DFSClient(InetSocketAddress, Configuration, org.apache.hadoop.fs.FileSystem.Statistics)

   */

  public DFSClient(InetSocketAddress nameNodeAddr, Configuration conf

      ) throws IOException {

    this(nameNodeAddr, conf, null);

  }

  /**

   * Same as this(nameNodeAddr, null, conf, stats);

   * @see #DFSClient(InetSocketAddress, ClientProtocol, Configuration, org.apache.hadoop.fs.FileSystem.Statistics)

   */

  public DFSClient(InetSocketAddress nameNodeAddr, Configuration conf,

                   FileSystem.Statistics stats)

    throws IOException {

    this(nameNodeAddr, null, conf, stats);

  }

  /**

   * Create a new DFSClient connected to the given nameNodeAddr or rpcNamenode.

   * Exactly one of nameNodeAddr or rpcNamenode must be null.

   */

  DFSClient(InetSocketAddress nameNodeAddr, ClientProtocol rpcNamenode,

      Configuration conf, FileSystem.Statistics stats)

    throws IOException {

    this(nameNodeAddr, rpcNamenode, conf, stats, 0, null);

  }

  /**

   * Create a new DFSClient connected to the given nameNodeAddr or rpcNamenode.

   * Exactly one of nameNodeAddr or rpcNamenode must be null.

   */

  DFSClient(InetSocketAddress nameNodeAddr, ClientProtocol rpcNamenode,

      Configuration conf, FileSystem.Statistics stats, long uniqueId,

      DistributedFileSystem dfs)

    throws IOException {

    this.dfs = dfs;

    this.conf = conf;

    this.metrics = new DFSClientMetrics(conf.getBoolean(

        "dfs.client.metrics.enable", false));

    this.stats = stats;

    this.socketTimeout = conf.getInt("dfs.socket.timeout",

                                     HdfsConstants.READ_TIMEOUT);

    this.socketReadExtentionTimeout = conf.getInt(

        HdfsConstants.DFS_DATANODE_READ_EXTENSION,

        HdfsConstants.READ_TIMEOUT_EXTENSION);

    this.namenodeRPCSocketTimeout = conf.getInt(

        DFS_CLIENT_NAMENODE_SOCKET_TIMEOUT, 0);

    this.timeoutValue = this.socketTimeout;

    this.datanodeWriteTimeout = conf.getInt("dfs.datanode.socket.write.timeout",

                                            HdfsConstants.WRITE_TIMEOUT);

    this.datanodeWriteExtentionTimeout = conf.getInt(