Examples with ClosedByInterruptException java.nio.channels.ClosedByInterruptException used on opensource projects

Example 6 with ClosedByInterruptException

use of java.nio.channels.ClosedByInterruptException in project robovm by robovm.

the class ClosedByInterruptExceptionTest method test_Constructor.

/**
     * @tests {@link java.nio.channels.ClosedByInterruptException#ClosedByInterruptException()}
     */
public void test_Constructor() {
    ClosedByInterruptException e = new ClosedByInterruptException();
    assertNull(e.getMessage());
    assertNull(e.getLocalizedMessage());
    assertNull(e.getCause());
}

Example 7 with ClosedByInterruptException

use of java.nio.channels.ClosedByInterruptException in project bazel by bazelbuild.

the class QueryCommand method exec.

/**
   * Exit codes:
   *   0   on successful evaluation.
   *   1   if query evaluation did not complete.
   *   2   if query parsing failed.
   *   3   if errors were reported but evaluation produced a partial result
   *        (only when --keep_going is in effect.)
   */
@Override
public ExitCode exec(CommandEnvironment env, OptionsProvider options) {
    BlazeRuntime runtime = env.getRuntime();
    QueryOptions queryOptions = options.getOptions(QueryOptions.class);
    try {
        env.setupPackageCache(options, runtime.getDefaultsPackageContent());
    } catch (InterruptedException e) {
        env.getReporter().handle(Event.error("query interrupted"));
        return ExitCode.INTERRUPTED;
    } catch (AbruptExitException e) {
        env.getReporter().handle(Event.error(null, "Unknown error: " + e.getMessage()));
        return e.getExitCode();
    }
    String query;
    if (!options.getResidue().isEmpty()) {
        if (!queryOptions.queryFile.isEmpty()) {
            env.getReporter().handle(Event.error("Command-line query and --query_file cannot both be specified"));
            return ExitCode.COMMAND_LINE_ERROR;
        }
        query = Joiner.on(' ').join(options.getResidue());
    } else if (!queryOptions.queryFile.isEmpty()) {
        // Works for absolute or relative query file.
        Path residuePath = env.getWorkingDirectory().getRelative(queryOptions.queryFile);
        try {
            query = new String(FileSystemUtils.readContent(residuePath), StandardCharsets.UTF_8);
        } catch (IOException e) {
            env.getReporter().handle(Event.error("I/O error reading from " + residuePath.getPathString()));
            return ExitCode.COMMAND_LINE_ERROR;
        }
    } else {
        env.getReporter().handle(Event.error(String.format("missing query expression. Type '%s help query' for syntax and help", runtime.getProductName())));
        return ExitCode.COMMAND_LINE_ERROR;
    }
    Iterable<OutputFormatter> formatters = runtime.getQueryOutputFormatters();
    OutputFormatter formatter = OutputFormatter.getFormatter(formatters, queryOptions.outputFormat);
    if (formatter == null) {
        env.getReporter().handle(Event.error(String.format("Invalid output format '%s'. Valid values are: %s", queryOptions.outputFormat, OutputFormatter.formatterNames(formatters))));
        return ExitCode.COMMAND_LINE_ERROR;
    }
    Set<Setting> settings = queryOptions.toSettings();
    boolean streamResults = QueryOutputUtils.shouldStreamResults(queryOptions, formatter);
    QueryEvalResult result;
    AbstractBlazeQueryEnvironment<Target> queryEnv = newQueryEnvironment(env, queryOptions.keepGoing, !streamResults, queryOptions.universeScope, queryOptions.loadingPhaseThreads, settings);
    // 1. Parse and transform query:
    QueryExpression expr;
    try {
        expr = QueryExpression.parse(query, queryEnv);
    } catch (QueryException e) {
        env.getReporter().handle(Event.error(null, "Error while parsing '" + query + "': " + e.getMessage()));
        return ExitCode.COMMAND_LINE_ERROR;
    }
    expr = queryEnv.transformParsedQuery(expr);
    OutputStream out = env.getReporter().getOutErr().getOutputStream();
    ThreadSafeOutputFormatterCallback<Target> callback;
    if (streamResults) {
        disableAnsiCharactersFiltering(env);
        // 2. Evaluate expression:
        StreamedFormatter streamedFormatter = ((StreamedFormatter) formatter);
        streamedFormatter.setOptions(queryOptions, queryOptions.aspectDeps.createResolver(env.getPackageManager(), env.getReporter()));
        callback = streamedFormatter.createStreamCallback(out, queryOptions, queryEnv);
    } else {
        callback = QueryUtil.newOrderedAggregateAllOutputFormatterCallback();
    }
    boolean catastrophe = true;
    try {
        result = queryEnv.evaluateQuery(expr, callback);
        catastrophe = false;
    } catch (QueryException e) {
        catastrophe = false;
        // Keep consistent with reportBuildFileError()
        env.getReporter().handle(Event.error(e.getMessage() == null ? e.toString() : e.getMessage()));
        return ExitCode.ANALYSIS_FAILURE;
    } catch (InterruptedException e) {
        catastrophe = false;
        IOException ioException = callback.getIoException();
        if (ioException == null || ioException instanceof ClosedByInterruptException) {
            env.getReporter().handle(Event.error("query interrupted"));
            return ExitCode.INTERRUPTED;
        } else {
            env.getReporter().handle(Event.error("I/O error: " + e.getMessage()));
            return ExitCode.LOCAL_ENVIRONMENTAL_ERROR;
        }
    } catch (IOException e) {
        catastrophe = false;
        env.getReporter().handle(Event.error("I/O error: " + e.getMessage()));
        return ExitCode.LOCAL_ENVIRONMENTAL_ERROR;
    } finally {
        if (!catastrophe) {
            try {
                out.flush();
            } catch (IOException e) {
                env.getReporter().handle(Event.error("Failed to flush query results: " + e.getMessage()));
                return ExitCode.LOCAL_ENVIRONMENTAL_ERROR;
            }
        }
    }
    env.getEventBus().post(new NoBuildEvent());
    if (!streamResults) {
        disableAnsiCharactersFiltering(env);
        // 3. Output results:
        try {
            Set<Target> targets = ((AggregateAllOutputFormatterCallback<Target>) callback).getResult();
            QueryOutputUtils.output(queryOptions, result, targets, formatter, env.getReporter().getOutErr().getOutputStream(), queryOptions.aspectDeps.createResolver(env.getPackageManager(), env.getReporter()));
        } catch (ClosedByInterruptException | InterruptedException e) {
            env.getReporter().handle(Event.error("query interrupted"));
            return ExitCode.INTERRUPTED;
        } catch (IOException e) {
            env.getReporter().handle(Event.error("I/O error: " + e.getMessage()));
            return ExitCode.LOCAL_ENVIRONMENTAL_ERROR;
        } finally {
            try {
                out.flush();
            } catch (IOException e) {
                env.getReporter().handle(Event.error("Failed to flush query results: " + e.getMessage()));
                return ExitCode.LOCAL_ENVIRONMENTAL_ERROR;
            }
        }
    }
    if (result.isEmpty()) {
        env.getReporter().handle(Event.info("Empty results"));
    }
    return result.getSuccess() ? ExitCode.SUCCESS : ExitCode.PARTIAL_ANALYSIS_FAILURE;
}

Example 8 with ClosedByInterruptException

use of java.nio.channels.ClosedByInterruptException in project nifi by apache.

the class SSLSocketChannelHandler method run.

@Override
public void run() {
    boolean eof = false;
    SSLSocketChannel sslSocketChannel = null;
    try {
        int bytesRead;
        final SocketChannel socketChannel = (SocketChannel) key.channel();
        final SocketChannelAttachment attachment = (SocketChannelAttachment) key.attachment();
        // get the SSLSocketChannel from the attachment
        sslSocketChannel = attachment.getSslSocketChannel();
        // SSLSocketChannel deals with byte[] so ByteBuffer isn't used here, but we'll use the size to create a new byte[]
        final ByteBuffer socketBuffer = attachment.getByteBuffer();
        byte[] socketBufferArray = new byte[socketBuffer.limit()];
        // read until no more data
        try {
            while ((bytesRead = sslSocketChannel.read(socketBufferArray)) > 0) {
                processBuffer(sslSocketChannel, socketChannel, bytesRead, socketBufferArray);
                logger.debug("bytes read from sslSocketChannel {}", new Object[] { bytesRead });
            }
        } catch (SocketTimeoutException ste) {
            // SSLSocketChannel will throw this exception when 0 bytes are read and the timeout threshold
            // is exceeded, we don't want to close the connection in this case
            bytesRead = 0;
        }
        // Check for closed socket
        if (bytesRead < 0) {
            eof = true;
            logger.debug("Reached EOF, closing connection");
        } else {
            logger.debug("No more data available, returning for selection");
        }
    } catch (ClosedByInterruptException | InterruptedException e) {
        logger.debug("read loop interrupted, closing connection");
        // Treat same as closed socket
        eof = true;
    } catch (ClosedChannelException e) {
        // ClosedChannelException doesn't have a message so handle it separately from IOException
        logger.error("Error reading from channel due to channel being closed", e);
        // Treat same as closed socket
        eof = true;
    } catch (IOException e) {
        logger.error("Error reading from channel due to {}", new Object[] { e.getMessage() }, e);
        // Treat same as closed socket
        eof = true;
    } finally {
        if (eof == true) {
            IOUtils.closeQuietly(sslSocketChannel);
            dispatcher.completeConnection(key);
        } else {
            dispatcher.addBackForSelection(key);
        }
    }
}

Example 9 with ClosedByInterruptException

use of java.nio.channels.ClosedByInterruptException in project nifi by apache.

the class SSLSocketChannel method writeFully.

private void writeFully(final ByteBuffer src) throws IOException {
    long lastByteWrittenTime = System.currentTimeMillis();
    int bytesWritten = 0;
    while (src.hasRemaining()) {
        if (interrupted) {
            throw new TransmissionDisabledException();
        }
        final int written = channel.write(src);
        bytesWritten += written;
        final long now = System.currentTimeMillis();
        long sleepNanos = 1L;
        if (written > 0) {
            lastByteWrittenTime = now;
        } else {
            if (now > lastByteWrittenTime + timeoutMillis) {
                throw new SocketTimeoutException("Timed out writing to socket connected to " + hostname + ":" + port);
            }
            try {
                TimeUnit.NANOSECONDS.sleep(sleepNanos);
            } catch (final InterruptedException e) {
                close();
                // set the interrupt status
                Thread.currentThread().interrupt();
                throw new ClosedByInterruptException();
            }
            sleepNanos = Math.min(sleepNanos * 2, BUFFER_FULL_EMPTY_WAIT_NANOS);
        }
    }
    logger.trace("{} Wrote {} bytes", this, bytesWritten);
}

Example 10 with ClosedByInterruptException

use of java.nio.channels.ClosedByInterruptException in project nifi by apache.

the class SSLSocketChannel method readData.

private int readData(final ByteBuffer dest) throws IOException {
    final long startTime = System.currentTimeMillis();
    while (true) {
        if (interrupted) {
            throw new TransmissionDisabledException();
        }
        if (dest.remaining() == 0) {
            return 0;
        }
        final int readCount = channel.read(dest);
        long sleepNanos = 1L;
        if (readCount == 0) {
            if (System.currentTimeMillis() > startTime + timeoutMillis) {
                throw new SocketTimeoutException("Timed out reading from socket connected to " + hostname + ":" + port);
            }
            try {
                TimeUnit.NANOSECONDS.sleep(sleepNanos);
            } catch (InterruptedException e) {
                close();
                // set the interrupt status
                Thread.currentThread().interrupt();
                throw new ClosedByInterruptException();
            }
            sleepNanos = Math.min(sleepNanos * 2, BUFFER_FULL_EMPTY_WAIT_NANOS);
            continue;
        }
        logger.trace("{} Read {} bytes", this, readCount);
        return readCount;
    }
}