Ejemplo n.º 1
0
 WriteManager(IdMappingServiceProvider iug, final NfsConfiguration config, boolean aixCompatMode) {
   this.iug = iug;
   this.config = config;
   this.aixCompatMode = aixCompatMode;
   streamTimeout =
       config.getLong(
           NfsConfigKeys.DFS_NFS_STREAM_TIMEOUT_KEY, NfsConfigKeys.DFS_NFS_STREAM_TIMEOUT_DEFAULT);
   LOG.info("Stream timeout is " + streamTimeout + "ms.");
   if (streamTimeout < NfsConfigKeys.DFS_NFS_STREAM_TIMEOUT_MIN_DEFAULT) {
     LOG.info(
         "Reset stream timeout to minimum value "
             + NfsConfigKeys.DFS_NFS_STREAM_TIMEOUT_MIN_DEFAULT
             + "ms.");
     streamTimeout = NfsConfigKeys.DFS_NFS_STREAM_TIMEOUT_MIN_DEFAULT;
   }
   maxStreams =
       config.getInt(
           NfsConfigKeys.DFS_NFS_MAX_OPEN_FILES_KEY, NfsConfigKeys.DFS_NFS_MAX_OPEN_FILES_DEFAULT);
   LOG.info("Maximum open streams is " + maxStreams);
   this.fileContextCache = new OpenFileCtxCache(config, streamTimeout);
 }
Ejemplo n.º 2
0
  void handleWrite(
      DFSClient dfsClient,
      WRITE3Request request,
      Channel channel,
      int xid,
      Nfs3FileAttributes preOpAttr)
      throws IOException {
    int count = request.getCount();
    byte[] data = request.getData().array();
    if (data.length < count) {
      WRITE3Response response = new WRITE3Response(Nfs3Status.NFS3ERR_INVAL);
      Nfs3Utils.writeChannel(channel, response.serialize(new XDR(), xid, new VerifierNone()), xid);
      return;
    }

    FileHandle handle = request.getHandle();
    if (LOG.isDebugEnabled()) {
      LOG.debug("handleWrite " + request);
    }

    // Check if there is a stream to write
    FileHandle fileHandle = request.getHandle();
    OpenFileCtx openFileCtx = fileContextCache.get(fileHandle);
    if (openFileCtx == null) {
      LOG.info("No opened stream for fileId:" + fileHandle.getFileId());

      String fileIdPath = Nfs3Utils.getFileIdPath(fileHandle.getFileId());
      HdfsDataOutputStream fos = null;
      Nfs3FileAttributes latestAttr = null;
      try {
        int bufferSize =
            config.getInt(
                CommonConfigurationKeysPublic.IO_FILE_BUFFER_SIZE_KEY,
                CommonConfigurationKeysPublic.IO_FILE_BUFFER_SIZE_DEFAULT);

        fos = dfsClient.append(fileIdPath, bufferSize, null, null);

        latestAttr = Nfs3Utils.getFileAttr(dfsClient, fileIdPath, iug);
      } catch (RemoteException e) {
        IOException io = e.unwrapRemoteException();
        if (io instanceof AlreadyBeingCreatedException) {
          LOG.warn(
              "Can't append file:"
                  + fileIdPath
                  + ". Possibly the file is being closed. Drop the request:"
                  + request
                  + ", wait for the client to retry...");
          return;
        }
        throw e;
      } catch (IOException e) {
        LOG.error("Can't apapend to file:" + fileIdPath, e);
        if (fos != null) {
          fos.close();
        }
        WccData fileWcc = new WccData(Nfs3Utils.getWccAttr(preOpAttr), preOpAttr);
        WRITE3Response response =
            new WRITE3Response(
                Nfs3Status.NFS3ERR_IO,
                fileWcc,
                count,
                request.getStableHow(),
                Nfs3Constant.WRITE_COMMIT_VERF);
        Nfs3Utils.writeChannel(
            channel, response.serialize(new XDR(), xid, new VerifierNone()), xid);
        return;
      }

      // Add open stream
      String writeDumpDir =
          config.get(
              NfsConfigKeys.DFS_NFS_FILE_DUMP_DIR_KEY, NfsConfigKeys.DFS_NFS_FILE_DUMP_DIR_DEFAULT);
      openFileCtx =
          new OpenFileCtx(
              fos,
              latestAttr,
              writeDumpDir + "/" + fileHandle.getFileId(),
              dfsClient,
              iug,
              aixCompatMode,
              config);

      if (!addOpenFileStream(fileHandle, openFileCtx)) {
        LOG.info("Can't add new stream. Close it. Tell client to retry.");
        try {
          fos.close();
        } catch (IOException e) {
          LOG.error("Can't close stream for fileId:" + handle.getFileId(), e);
        }
        // Notify client to retry
        WccData fileWcc = new WccData(latestAttr.getWccAttr(), latestAttr);
        WRITE3Response response =
            new WRITE3Response(
                Nfs3Status.NFS3ERR_JUKEBOX,
                fileWcc,
                0,
                request.getStableHow(),
                Nfs3Constant.WRITE_COMMIT_VERF);
        Nfs3Utils.writeChannel(
            channel, response.serialize(new XDR(), xid, new VerifierNone()), xid);
        return;
      }

      if (LOG.isDebugEnabled()) {
        LOG.debug("Opened stream for appending file:" + fileHandle.getFileId());
      }
    }

    // Add write into the async job queue
    openFileCtx.receivedNewWrite(dfsClient, request, channel, xid, asyncDataService, iug);
    return;
  }