* 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 long SERVER_DEFAULTS_VALIDITY_PERIOD = 60 * 60 * 1000L; // 1 hour

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

  private final Configuration conf;

  private final Conf dfsClientConf;

  final ClientProtocol namenode;

  /* The service used for delegation tokens */

  private Text dtService;

  final UserGroupInformation ugi;

  volatile boolean clientRunning = true;

  volatile long lastLeaseRenewal;

  private volatile FsServerDefaults serverDefaults;

  private volatile long serverDefaultsLastUpdate;

  final String clientName;

  SocketFactory socketFactory;

  final ReplaceDatanodeOnFailure dtpReplaceDatanodeOnFailure;

  final FileSystem.Statistics stats;

  private final String authority;

  final PeerCache peerCache;

  private Random r = new Random();

  private SocketAddress[] localInterfaceAddrs;

  private DataEncryptionKey encryptionKey;

  private boolean shouldUseLegacyBlockReaderLocal;

 

  /**

   * DFSClient configuration

   */

  public static class Conf {

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

    final int maxFailoverAttempts;

    final int failoverSleepBaseMillis;

    final int failoverSleepMaxMillis;

    final int maxBlockAcquireFailures;

    final int confTime;

    final int ioBufferSize;

    final ChecksumOpt defaultChecksumOpt;

    final int writePacketSize;

    final int socketTimeout;

    final int socketCacheCapacity;

    final long socketCacheExpiry;

    final long excludedNodesCacheExpiry;

    /** Wait time window (in msec) if BlockMissingException is caught */

    final int timeWindow;

    final int nCachedConnRetry;

    final int nBlockWriteRetry;

    final int nBlockWriteLocateFollowingRetry;

    final long defaultBlockSize;

    final long prefetchSize;

    final short defaultReplication;

    final String taskId;

    final FsPermission uMask;

    final boolean connectToDnViaHostname;

    final boolean getHdfsBlocksMetadataEnabled;

    final int getFileBlockStorageLocationsNumThreads;

    final int getFileBlockStorageLocationsTimeout;

    final boolean useLegacyBlockReader;

    final boolean useLegacyBlockReaderLocal;

    final String domainSocketPath;

    final boolean skipShortCircuitChecksums;

    final int shortCircuitBufferSize;

    final boolean shortCircuitLocalReads;

    final boolean domainSocketDataTraffic;

    final int shortCircuitStreamsCacheSize;

    final long shortCircuitStreamsCacheExpiryMs;

    public Conf(Configuration conf) {

      // The hdfsTimeout is currently the same as the ipc timeout

      hdfsTimeout = Client.getTimeout(conf);

      maxFailoverAttempts = conf.getInt(

          DFS_CLIENT_FAILOVER_MAX_ATTEMPTS_KEY,

          DFS_CLIENT_FAILOVER_MAX_ATTEMPTS_DEFAULT);

      failoverSleepBaseMillis = conf.getInt(

          DFS_CLIENT_FAILOVER_SLEEPTIME_BASE_KEY,

          DFS_CLIENT_FAILOVER_SLEEPTIME_BASE_DEFAULT);

      failoverSleepMaxMillis = conf.getInt(

          DFS_CLIENT_FAILOVER_SLEEPTIME_MAX_KEY,

          DFS_CLIENT_FAILOVER_SLEEPTIME_MAX_DEFAULT);

      maxBlockAcquireFailures = conf.getInt(

          DFS_CLIENT_MAX_BLOCK_ACQUIRE_FAILURES_KEY,

          DFS_CLIENT_MAX_BLOCK_ACQUIRE_FAILURES_DEFAULT);

      confTime = conf.getInt(DFS_DATANODE_SOCKET_WRITE_TIMEOUT_KEY,

          HdfsServerConstants.WRITE_TIMEOUT);

      ioBufferSize = conf.getInt(

          CommonConfigurationKeysPublic.IO_FILE_BUFFER_SIZE_KEY,

          CommonConfigurationKeysPublic.IO_FILE_BUFFER_SIZE_DEFAULT);

      defaultChecksumOpt = getChecksumOptFromConf(conf);

      socketTimeout = conf.getInt(DFS_CLIENT_SOCKET_TIMEOUT_KEY,

          HdfsServerConstants.READ_TIMEOUT);

      /** dfs.write.packet.size is an internal config variable */

      writePacketSize = conf.getInt(DFS_CLIENT_WRITE_PACKET_SIZE_KEY,

          DFS_CLIENT_WRITE_PACKET_SIZE_DEFAULT);

      defaultBlockSize = conf.getLongBytes(DFS_BLOCK_SIZE_KEY,

          DFS_BLOCK_SIZE_DEFAULT);

      defaultReplication = (short) conf.getInt(

          DFS_REPLICATION_KEY, DFS_REPLICATION_DEFAULT);

      taskId = conf.get("mapreduce.task.attempt.id", "NONMAPREDUCE");

      socketCacheCapacity = conf.getInt(DFS_CLIENT_SOCKET_CACHE_CAPACITY_KEY,

          DFS_CLIENT_SOCKET_CACHE_CAPACITY_DEFAULT);

      socketCacheExpiry = conf.getLong(DFS_CLIENT_SOCKET_CACHE_EXPIRY_MSEC_KEY,

          DFS_CLIENT_SOCKET_CACHE_EXPIRY_MSEC_DEFAULT);

      excludedNodesCacheExpiry = conf.getLong(

          DFS_CLIENT_WRITE_EXCLUDE_NODES_CACHE_EXPIRY_INTERVAL,

          DFS_CLIENT_WRITE_EXCLUDE_NODES_CACHE_EXPIRY_INTERVAL_DEFAULT);

      prefetchSize = conf.getLong(DFS_CLIENT_READ_PREFETCH_SIZE_KEY,

          10 * defaultBlockSize);

      timeWindow = conf.getInt(DFS_CLIENT_RETRY_WINDOW_BASE, 3000);

      nCachedConnRetry = conf.getInt(DFS_CLIENT_CACHED_CONN_RETRY_KEY,

          DFS_CLIENT_CACHED_CONN_RETRY_DEFAULT);

      nBlockWriteRetry = conf.getInt(DFS_CLIENT_BLOCK_WRITE_RETRIES_KEY,

          DFS_CLIENT_BLOCK_WRITE_RETRIES_DEFAULT);

      nBlockWriteLocateFollowingRetry = conf.getInt(

          DFS_CLIENT_BLOCK_WRITE_LOCATEFOLLOWINGBLOCK_RETRIES_KEY,

          DFS_CLIENT_BLOCK_WRITE_LOCATEFOLLOWINGBLOCK_RETRIES_DEFAULT);

      uMask = FsPermission.getUMask(conf);

      connectToDnViaHostname = conf.getBoolean(DFS_CLIENT_USE_DN_HOSTNAME,

          DFS_CLIENT_USE_DN_HOSTNAME_DEFAULT);

      getHdfsBlocksMetadataEnabled = conf.getBoolean(

          DFSConfigKeys.DFS_HDFS_BLOCKS_METADATA_ENABLED,

          DFSConfigKeys.DFS_HDFS_BLOCKS_METADATA_ENABLED_DEFAULT);

      getFileBlockStorageLocationsNumThreads = conf.getInt(

          DFSConfigKeys.DFS_CLIENT_FILE_BLOCK_STORAGE_LOCATIONS_NUM_THREADS,

          DFSConfigKeys.DFS_CLIENT_FILE_BLOCK_STORAGE_LOCATIONS_NUM_THREADS_DEFAULT);

      getFileBlockStorageLocationsTimeout = conf.getInt(

          DFSConfigKeys.DFS_CLIENT_FILE_BLOCK_STORAGE_LOCATIONS_TIMEOUT,

          DFSConfigKeys.DFS_CLIENT_FILE_BLOCK_STORAGE_LOCATIONS_TIMEOUT_DEFAULT);

      useLegacyBlockReader = conf.getBoolean(

          DFSConfigKeys.DFS_CLIENT_USE_LEGACY_BLOCKREADER,

          DFSConfigKeys.DFS_CLIENT_USE_LEGACY_BLOCKREADER_DEFAULT);

      useLegacyBlockReaderLocal = conf.getBoolean(

          DFSConfigKeys.DFS_CLIENT_USE_LEGACY_BLOCKREADERLOCAL,

          DFSConfigKeys.DFS_CLIENT_USE_LEGACY_BLOCKREADERLOCAL_DEFAULT);

      shortCircuitLocalReads = conf.getBoolean(

          DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_KEY,

          DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_DEFAULT);

      domainSocketDataTraffic = conf.getBoolean(

          DFSConfigKeys.DFS_CLIENT_DOMAIN_SOCKET_DATA_TRAFFIC,

          DFSConfigKeys.DFS_CLIENT_DOMAIN_SOCKET_DATA_TRAFFIC_DEFAULT);

      domainSocketPath = conf.getTrimmed(

          DFSConfigKeys.DFS_DOMAIN_SOCKET_PATH_KEY,

          DFSConfigKeys.DFS_DOMAIN_SOCKET_PATH_DEFAULT);

      if (BlockReaderLocal.LOG.isDebugEnabled()) {

        BlockReaderLocal.LOG.debug(

            DFSConfigKeys.DFS_CLIENT_USE_LEGACY_BLOCKREADERLOCAL

            + " = " + useLegacyBlockReaderLocal);

        BlockReaderLocal.LOG.debug(

            DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_KEY

            + " = " + shortCircuitLocalReads);

        BlockReaderLocal.LOG.debug(

            DFSConfigKeys.DFS_CLIENT_DOMAIN_SOCKET_DATA_TRAFFIC

            + " = " + domainSocketDataTraffic);

        BlockReaderLocal.LOG.debug(

            DFSConfigKeys.DFS_DOMAIN_SOCKET_PATH_KEY

            + " = " + domainSocketPath);

      }

      skipShortCircuitChecksums = conf.getBoolean(

          DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_SKIP_CHECKSUM_KEY,

          DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_SKIP_CHECKSUM_DEFAULT);

      shortCircuitBufferSize = conf.getInt(

          DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_BUFFER_SIZE_KEY,

          DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_BUFFER_SIZE_DEFAULT);

      shortCircuitStreamsCacheSize = conf.getInt(

          DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_STREAMS_CACHE_SIZE_KEY,

          DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_STREAMS_CACHE_SIZE_DEFAULT);

      shortCircuitStreamsCacheExpiryMs = conf.getLong(

          DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_STREAMS_CACHE_EXPIRY_MS_KEY,

          DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_STREAMS_CACHE_EXPIRY_MS_DEFAULT);

    }

    private DataChecksum.Type getChecksumType(Configuration conf) {

      final String checksum = conf.get(

          DFSConfigKeys.DFS_CHECKSUM_TYPE_KEY,

          DFSConfigKeys.DFS_CHECKSUM_TYPE_DEFAULT);

      try {

        return DataChecksum.Type.valueOf(checksum);

      } catch(IllegalArgumentException iae) {

        LOG.warn("Bad checksum type: " + checksum + ". Using default "

            + DFSConfigKeys.DFS_CHECKSUM_TYPE_DEFAULT);

        return DataChecksum.Type.valueOf(

            DFSConfigKeys.DFS_CHECKSUM_TYPE_DEFAULT);

      }

    }

    // Construct a checksum option from conf

    private ChecksumOpt getChecksumOptFromConf(Configuration conf) {

      DataChecksum.Type type = getChecksumType(conf);

      int bytesPerChecksum = conf.getInt(DFS_BYTES_PER_CHECKSUM_KEY,

          DFS_BYTES_PER_CHECKSUM_DEFAULT);

      return new ChecksumOpt(type, bytesPerChecksum);

    }

    // create a DataChecksum with the default option.

    private DataChecksum createChecksum() throws IOException {

      return createChecksum(null);

    }

    private DataChecksum createChecksum(ChecksumOpt userOpt)

        throws IOException {

      // Fill in any missing field with the default.

      ChecksumOpt myOpt = ChecksumOpt.processChecksumOpt(

          defaultChecksumOpt, userOpt);

      DataChecksum dataChecksum = DataChecksum.newDataChecksum(

          myOpt.getChecksumType(),

          myOpt.getBytesPerChecksum());

      if (dataChecksum == null) {

        throw new IOException("Invalid checksum type specified: "

            + myOpt.getChecksumType().name());

      }

      return dataChecksum;

    }

  }

  public Conf getConf() {

    return dfsClientConf;

  }

 

  Configuration getConfiguration() {

    return conf;

  }

 

  /**

   * A map from file names to {@link DFSOutputStream} objects

   * that are currently being written by this client.

   * Note that a file can only be written by a single client.

   */

  private final Map<String, DFSOutputStream> filesBeingWritten

      = new HashMap<String, DFSOutputStream>();

  private final DomainSocketFactory domainSocketFactory;

 

  /**

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

   * @see #DFSClient(InetSocketAddress, Configuration)

   * @deprecated Deprecated at 0.21

   */

  @Deprecated

  public DFSClient(Configuration conf) throws IOException {

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

  }

 

  public DFSClient(InetSocketAddress address, Configuration conf) throws IOException {

    this(NameNode.getUri(address), conf);

  }

  /**

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

   * @see #DFSClient(URI, Configuration, FileSystem.Statistics)

   */

  public DFSClient(URI nameNodeUri, Configuration conf

      ) throws IOException {

    this(nameNodeUri, conf, null);

  }

  /**

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

   * @see #DFSClient(URI, ClientProtocol, Configuration, FileSystem.Statistics)

   */

  public DFSClient(URI nameNodeUri, Configuration conf,

                   FileSystem.Statistics stats)

    throws IOException {

    this(nameNodeUri, null, conf, stats);

  }

 

  /**

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

   * Exactly one of nameNodeUri or rpcNamenode must be null.

   */

  @VisibleForTesting

  public DFSClient(URI nameNodeUri, ClientProtocol rpcNamenode,

      Configuration conf, FileSystem.Statistics stats)

    throws IOException {

    // Copy only the required DFSClient configuration

    this.dfsClientConf = new Conf(conf);

    this.shouldUseLegacyBlockReaderLocal =

        this.dfsClientConf.useLegacyBlockReaderLocal;

    if (this.dfsClientConf.useLegacyBlockReaderLocal) {

      LOG.debug("Using legacy short-circuit local reads.");

    }

    this.conf = conf;

    this.stats = stats;

    this.socketFactory = NetUtils.getSocketFactory(conf, ClientProtocol.class);

    this.dtpReplaceDatanodeOnFailure = ReplaceDatanodeOnFailure.get(conf);

    this.ugi = UserGroupInformation.getCurrentUser();

   

    this.authority = nameNodeUri == null? "null": nameNodeUri.getAuthority();

    this.clientName = "DFSClient_" + dfsClientConf.taskId + "_" +

        DFSUtil.getRandom().nextInt()  + "_" + Thread.currentThread().getId();

   

    if (rpcNamenode != null) {

      // This case is used for testing.

      Preconditions.checkArgument(nameNodeUri == null);

      this.namenode = rpcNamenode;

      dtService = null;

    } else {

      Preconditions.checkArgument(nameNodeUri != null,

          "null URI");

      NameNodeProxies.ProxyAndInfo<ClientProtocol> proxyInfo =

        NameNodeProxies.createProxy(conf, nameNodeUri, ClientProtocol.class);

     

      this.dtService = proxyInfo.getDelegationTokenService();

      this.namenode = proxyInfo.getProxy();

    }

    // read directly from the block file if configured.

    this.domainSocketFactory = new DomainSocketFactory(dfsClientConf);

    String localInterfaces[] =

      conf.getTrimmedStrings(DFSConfigKeys.DFS_CLIENT_LOCAL_INTERFACES);

    localInterfaceAddrs = getLocalInterfaceAddrs(localInterfaces);

    if (LOG.isDebugEnabled() && 0 != localInterfaces.length) {

      LOG.debug("Using local interfaces [" +

      Joiner.on(',').join(localInterfaces)+ "] with addresses [" +

      Joiner.on(',').join(localInterfaceAddrs) + "]");

    }

   

    this.peerCache = PeerCache.getInstance(dfsClientConf.socketCacheCapacity, dfsClientConf.socketCacheExpiry);

  }

  /**

   * Return the socket addresses to use with each configured

   * local interface. Local interfaces may be specified by IP

   * address, IP address range using CIDR notation, interface

   * name (e.g. eth0) or sub-interface name (e.g. eth0:0).

   * The socket addresses consist of the IPs for the interfaces

   * and the ephemeral port (port 0). If an IP, IP range, or

   * interface name matches an interface with sub-interfaces

   * only the IP of the interface is used. Sub-interfaces can

   * be used by specifying them explicitly (by IP or name).

   *

   * @return SocketAddresses for the configured local interfaces,

   *    or an empty array if none are configured

   * @throws UnknownHostException if a given interface name is invalid

   */

  private static SocketAddress[] getLocalInterfaceAddrs(

      String interfaceNames[]) throws UnknownHostException {

    List<SocketAddress> localAddrs = new ArrayList<SocketAddress>();

    for (String interfaceName : interfaceNames) {

      if (InetAddresses.isInetAddress(interfaceName)) {

        localAddrs.add(new InetSocketAddress(interfaceName, 0));

      } else if (NetUtils.isValidSubnet(interfaceName)) {

        for (InetAddress addr : NetUtils.getIPs(interfaceName, false)) {

          localAddrs.add(new InetSocketAddress(addr, 0));

        }

      } else {

        for (String ip : DNS.getIPs(interfaceName, false)) {

          localAddrs.add(new InetSocketAddress(ip, 0));

        }

      }

    }

    return localAddrs.toArray(new SocketAddress[localAddrs.size()]);

  }

  /**

   * Select one of the configured local interfaces at random. We use a random

   * interface because other policies like round-robin are less effective

   * given that we cache connections to datanodes.

   *

   * @return one of the local interface addresses at random, or null if no

   *    local interfaces are configured

   */

  SocketAddress getRandomLocalInterfaceAddr() {

    if (localInterfaceAddrs.length == 0) {

      return null;

    }

    final int idx = r.nextInt(localInterfaceAddrs.length);

    final SocketAddress addr = localInterfaceAddrs[idx];

    if (LOG.isDebugEnabled()) {

      LOG.debug("Using local interface " + addr);

    }

    return addr;

  }

  /**

   * Return the number of times the client should go back to the namenode

   * to retrieve block locations when reading.

   */

  int getMaxBlockAcquireFailures() {

    return dfsClientConf.maxBlockAcquireFailures;

  }

  /**

   * Return the timeout that clients should use when writing to datanodes.

   * @param numNodes the number of nodes in the pipeline.

   */

  int getDatanodeWriteTimeout(int numNodes) {

    return (dfsClientConf.confTime > 0) ?

      (dfsClientConf.confTime + HdfsServerConstants.WRITE_TIMEOUT_EXTENSION * numNodes) : 0;

  }

  int getDatanodeReadTimeout(int numNodes) {

    return dfsClientConf.socketTimeout > 0 ?

        (HdfsServerConstants.READ_TIMEOUT_EXTENSION * numNodes +

            dfsClientConf.socketTimeout) : 0;

  }

 

  int getHdfsTimeout() {

    return dfsClientConf.hdfsTimeout;

  }

 

  String getClientName() {

    return clientName;

  }

  void checkOpen() throws IOException {

    if (!clientRunning) {

      IOException result = new IOException("Filesystem closed");

      throw result;

    }

  }

  /** Return the lease renewer instance. The renewer thread won't start

   *  until the first output stream is created. The same instance will

   *  be returned until all output streams are closed.

   */

  public LeaseRenewer getLeaseRenewer() throws IOException {

      return LeaseRenewer.getInstance(authority, ugi, this);

  }

  /** Get a lease and start automatic renewal */

  private void beginFileLease(final String src, final DFSOutputStream out)

      throws IOException {

    getLeaseRenewer().put(src, out, this);

  }

  /** Stop renewal of lease for the file. */

  void endFileLease(final String src) throws IOException {

    getLeaseRenewer().closeFile(src, this);

  }

   

  /** Put a file. Only called from LeaseRenewer, where proper locking is

   *  enforced to consistently update its local dfsclients array and

   *  client's filesBeingWritten map.

   */

  void putFileBeingWritten(final String src, final DFSOutputStream out) {

    synchronized(filesBeingWritten) {

      filesBeingWritten.put(src, out);

      // update the last lease renewal time only when there was no

      // writes. once there is one write stream open, the lease renewer

      // thread keeps it updated well with in anyone's expiration time.

      if (lastLeaseRenewal == 0) {

        updateLastLeaseRenewal();

      }

    }

  }

  /** Remove a file. Only called from LeaseRenewer. */

  void removeFileBeingWritten(final String src) {

    synchronized(filesBeingWritten) {

      filesBeingWritten.remove(src);

      if (filesBeingWritten.isEmpty()) {

        lastLeaseRenewal = 0;

      }

    }

  }

  /** Is file-being-written map empty? */

  boolean isFilesBeingWrittenEmpty() {

    synchronized(filesBeingWritten) {

      return filesBeingWritten.isEmpty();

    }

  }

 

  /** @return true if the client is running */

  boolean isClientRunning() {

    return clientRunning;

  }

  long getLastLeaseRenewal() {

    return lastLeaseRenewal;

  }

  void updateLastLeaseRenewal() {

    synchronized(filesBeingWritten) {

      if (filesBeingWritten.isEmpty()) {

        return;

      }

      lastLeaseRenewal = Time.now();

    }

  }

  /**

   * Renew leases.

   * @return true if lease was renewed. May return false if this

   * client has been closed or has no files open.

   **/

  boolean renewLease() throws IOException {

    if (clientRunning && !isFilesBeingWrittenEmpty()) {

      try {

        namenode.renewLease(clientName);

        updateLastLeaseRenewal();

        return true;

      } catch (IOException e) {

        // Abort if the lease has already expired.

        final long elapsed = Time.now() - getLastLeaseRenewal();

        if (elapsed > HdfsConstants.LEASE_HARDLIMIT_PERIOD) {

          LOG.warn("Failed to renew lease for " + clientName + " for "

              + (elapsed/1000) + " seconds (>= soft-limit ="

              + (HdfsConstants.LEASE_HARDLIMIT_PERIOD/1000) + " seconds.) "

              + "Closing all files being written ...", e);

          closeAllFilesBeingWritten(true);

        } else {

          // Let the lease renewer handle it and retry.

          throw e;

        }

      }

    }

    return false;

  }

 

  /**

   * Close connections the Namenode.

   */

  void closeConnectionToNamenode() {

    RPC.stopProxy(namenode);

  }

 

  /** Abort and release resources held.  Ignore all errors. */

  void abort() {

    clientRunning = false;

    closeAllFilesBeingWritten(true);

    try {

      // remove reference to this client and stop the renewer,

      // if there is no more clients under the renewer.

      getLeaseRenewer().closeClient(this);

    } catch (IOException ioe) {

       LOG.info("Exception occurred while aborting the client " + ioe);

    }

    closeConnectionToNamenode();

  }

  /** Close/abort all files being written. */

  private void closeAllFilesBeingWritten(final boolean abort) {

    for(;;) {

      final String src;

      final DFSOutputStream out;

      synchronized(filesBeingWritten) {

        if (filesBeingWritten.isEmpty()) {

          return;

        }

        src = filesBeingWritten.keySet().iterator().next();

        out = filesBeingWritten.remove(src);

      }

      if (out != null) {

        try {

          if (abort) {

            out.abort();

          } else {

            out.close();

          }

        } catch(IOException ie) {

          LOG.error("Failed to " + (abort? "abort": "close") + " file " + src,

              ie);

        }

      }

    }

  }

  /**

   * Close the file system, abandoning all of the leases and files being

   * created and close connections to the namenode.

   */

  @Override

  public synchronized void close() throws IOException {

    if(clientRunning) {

      closeAllFilesBeingWritten(false);

      clientRunning = false;

      getLeaseRenewer().closeClient(this);

      // close connections to the namenode

      closeConnectionToNamenode();

    }

  }

  /**

   * Get the default block size for this cluster

   * @return the default block size in bytes

   */

  public long getDefaultBlockSize() {

    return dfsClientConf.defaultBlockSize;

  }

   

  /**

   * @see ClientProtocol#getPreferredBlockSize(String)

   */

  public long getBlockSize(String f) throws IOException {

    try {

      return namenode.getPreferredBlockSize(f);

    } catch (IOException ie) {

      LOG.warn("Problem getting block size", ie);

      throw ie;

    }

  }

  /**

   * Get server default values for a number of configuration params.

   * @see ClientProtocol#getServerDefaults()

   */

  public FsServerDefaults getServerDefaults() throws IOException {

    long now = Time.now();

    if (now - serverDefaultsLastUpdate > SERVER_DEFAULTS_VALIDITY_PERIOD) {

      serverDefaults = namenode.getServerDefaults();

      serverDefaultsLastUpdate = now;

    }

    return serverDefaults;

  }

 

  /**

   * Get a canonical token service name for this client's tokens.  Null should

   * be returned if the client is not using tokens.

   * @return the token service for the client

   */

  @InterfaceAudience.LimitedPrivate( { "HDFS" })

  public String getCanonicalServiceName() {

    return (dtService != null) ? dtService.toString() : null;

  }

 

  /**

   * @see ClientProtocol#getDelegationToken(Text)

   */

  public Token<DelegationTokenIdentifier> getDelegationToken(Text renewer)

      throws IOException {

    assert dtService != null;

    Token<DelegationTokenIdentifier> token =

      namenode.getDelegationToken(renewer);

    token.setService(this.dtService);

    LOG.info("Created " + DelegationTokenIdentifier.stringifyToken(token));

    return token;

  }

  /**

   * Renew a delegation token

   * @param token the token to renew

   * @return the new expiration time

   * @throws InvalidToken

   * @throws IOException

   * @deprecated Use Token.renew instead.

   */

  @Deprecated

  public long renewDelegationToken(Token<DelegationTokenIdentifier> token)

      throws InvalidToken, IOException {

    LOG.info("Renewing " + DelegationTokenIdentifier.stringifyToken(token));

    try {

      return token.renew(conf);

    } catch (InterruptedException ie) {                                      

      throw new RuntimeException("caught interrupted", ie);

    } catch (RemoteException re) {

      throw re.unwrapRemoteException(InvalidToken.class,

                                     AccessControlException.class);

    }

  }

 

  private static Map<String, Boolean> localAddrMap = Collections

      .synchronizedMap(new HashMap<String, Boolean>());

 

  static boolean isLocalAddress(InetSocketAddress targetAddr) {

    InetAddress addr = targetAddr.getAddress();

    Boolean cached = localAddrMap.get(addr.getHostAddress());

    if (cached != null) {

      if (LOG.isTraceEnabled()) {

        LOG.trace("Address " + targetAddr +

                  (cached ? " is local" : " is not local"));

      }

      return cached;

    }

   

    boolean local = NetUtils.isLocalAddress(addr);

    if (LOG.isTraceEnabled()) {

      LOG.trace("Address " + targetAddr +

                (local ? " is local" : " is not local"));

    }

    localAddrMap.put(addr.getHostAddress(), local);

    return local;

  }

 

  /**

   * Should the block access token be refetched on an exception

   *

   * @param ex Exception received

   * @param targetAddr Target datanode address from where exception was received

   * @return true if block access token has expired or invalid and it should be

   *         refetched

   */

  private static boolean tokenRefetchNeeded(IOException ex,

      InetSocketAddress targetAddr) {

    /*

     * Get a new access token and retry. Retry is needed in 2 cases. 1) When

     * both NN and DN re-started while DFSClient holding a cached access token.

     * 2) In the case that NN fails to update its access key at pre-set interval

     * (by a wide margin) and subsequently restarts. In this case, DN

     * re-registers itself with NN and receives a new access key, but DN will

     * delete the old access key from its memory since it's considered expired

     * based on the estimated expiration date.

     */

    if (ex instanceof InvalidBlockTokenException || ex instanceof InvalidToken) {

      LOG.info("Access token was invalid when connecting to " + targetAddr

          + " : " + ex);

      return true;

    }

    return false;

  }

 

  /**

   * Cancel a delegation token

   * @param token the token to cancel

   * @throws InvalidToken

   * @throws IOException

   * @deprecated Use Token.cancel instead.

   */

  @Deprecated

  public void cancelDelegationToken(Token<DelegationTokenIdentifier> token)

      throws InvalidToken, IOException {

    LOG.info("Cancelling " + DelegationTokenIdentifier.stringifyToken(token));

    try {

      token.cancel(conf);

     } catch (InterruptedException ie) {                                      

      throw new RuntimeException("caught interrupted", ie);

    } catch (RemoteException re) {

      throw re.unwrapRemoteException(InvalidToken.class,

                                     AccessControlException.class);

    }

  }

 

  @InterfaceAudience.Private

  public static class Renewer extends TokenRenewer {

   

    static {

      //Ensure that HDFS Configuration files are loaded before trying to use

      // the renewer.

      HdfsConfiguration.init();

    }

   

    @Override

    public boolean handleKind(Text kind) {

      return DelegationTokenIdentifier.HDFS_DELEGATION_KIND.equals(kind);

    }

    @SuppressWarnings("unchecked")

    @Override

    public long renew(Token<?> token, Configuration conf) throws IOException {