private SearcherManager createSearcherManager() throws EngineException {
   boolean success = false;
   SearcherManager searcherManager = null;
   try {
     try {
       final DirectoryReader directoryReader =
           ElasticsearchDirectoryReader.wrap(DirectoryReader.open(indexWriter), shardId);
       searcherManager = new SearcherManager(directoryReader, searcherFactory);
       lastCommittedSegmentInfos = readLastCommittedSegmentInfos(searcherManager, store);
       success = true;
       return searcherManager;
     } catch (IOException e) {
       maybeFailEngine("start", e);
       try {
         indexWriter.rollback();
       } catch (IOException e1) { // iw is closed below
         e.addSuppressed(e1);
       }
       throw new EngineCreationFailureException(shardId, "failed to open reader on writer", e);
     }
   } finally {
     if (success == false) { // release everything we created on a failure
       IOUtils.closeWhileHandlingException(searcherManager, indexWriter);
     }
   }
 }
  /**
   * Opens an input stream to this location.
   *
   * <p>Please note that it will try to obtain a stream from every storage until a storage returns
   * one.
   *
   * @return The input-stream to this location.
   */
  @Override
  public InputStream getInputStream() throws IOException {
    // Sine we are going to suppress all unhandles IOExceptions and only throw them
    // if we were unable to get a stream, we will access the location.
    List<IOException> exceptionList = new ArrayList<IOException>();

    // Try all locations but try the write-storage first.
    for (ConfigurationStorage cs :
        ArrayUtils.add(this.storage.getChildStorage(), 0, this.storage.getWriteStorage())) {
      // Try to access the storage location.
      InputStream is = null;
      try {
        is = cs.getInputStream(this.module, this.configuration);
      } catch (IOException e) {
        // Just suppress IOExceptions.
        exceptionList.add(e);
      }

      // If we were able to access the location, return the stream.
      if (is != null) return is;
    }

    if (exceptionList.size() == 0) return null;
    else if (exceptionList.size() == 1) {
      // Just rethrow the only one that occured.
      throw exceptionList.get(0);
    } else {
      // Throw all suppressed exceptions.
      IOException exception =
          new IOException(
              "Failed to obtain the stream. The following exceptions have been suppressed.");
      for (IOException e : exceptionList) exception.addSuppressed(e);
      throw exception;
    }
  }
Exemple #3
0
 /**
  * Ensures configured directory {@code path} exists.
  *
  * @throws IOException if {@code path} exists, but is not a directory, not accessible, or broken
  *     symbolic link.
  */
 static void ensureDirectoryExists(Path path) throws IOException {
   // this isn't atomic, but neither is createDirectories.
   if (Files.isDirectory(path)) {
     // verify access, following links (throws exception if something is wrong)
     // we only check READ as a sanity test
     path.getFileSystem().provider().checkAccess(path.toRealPath(), AccessMode.READ);
   } else {
     // doesn't exist, or not a directory
     try {
       Files.createDirectories(path);
     } catch (FileAlreadyExistsException e) {
       // convert optional specific exception so the context is clear
       IOException e2 = new NotDirectoryException(path.toString());
       e2.addSuppressed(e);
       throw e2;
     }
   }
 }
 @Override
 public void close() throws IOException {
   IOException e = null;
   for (InputStream stream : opened) {
     try {
       stream.close();
     } catch (IOException ex) {
       if (e == null) {
         e = ex;
       } else {
         e.addSuppressed(ex);
       }
     }
   }
   if (e != null) {
     throw e;
   }
 }
 @Override
 public DatagramChannel create() throws ObjectCreationException {
   DatagramChannel datagramChannel;
   try {
     datagramChannel = DatagramChannel.open();
   } catch (IOException ex) {
     throw new ObjectCreationException(ex);
   }
   try {
     datagramChannel.connect(address);
     return datagramChannel;
   } catch (IOException ex) {
     try {
       datagramChannel.close();
     } catch (IOException ex1) {
       ex1.addSuppressed(ex);
       throw new ObjectCreationException(ex1);
     }
     throw new ObjectCreationException(ex);
   }
 }
  @Override
  public void close() throws IOException {

    IOException cause = null;
    for (DataStoreTransaction transaction : transactions.values()) {
      try {
        transaction.close();
      } catch (IOException | Error | RuntimeException e) {
        if (cause != null) {
          cause.addSuppressed(e);
        } else if (e instanceof IOException) {
          cause = (IOException) e;
        } else {
          cause = new IOException(e);
        }
      }
    }
    transactions.clear();
    if (cause != null) {
      throw cause;
    }
  }