Examples with Response org.apache.nifi.remote.protocol.Response used on opensource projects

Example 11 with Response

use of org.apache.nifi.remote.protocol.Response in project nifi by apache.

the class AbstractTransaction method receive.

@Override
public final DataPacket receive() throws IOException {
    try {
        try {
            if (state != TransactionState.DATA_EXCHANGED && state != TransactionState.TRANSACTION_STARTED) {
                throw new IllegalStateException("Cannot receive data from " + peer + " because Transaction State is " + state);
            }
            if (direction == TransferDirection.SEND) {
                throw new IllegalStateException("Attempting to receive data from " + peer + " but started a SEND Transaction");
            }
            // if we already know there's no data, just return null
            if (!dataAvailable) {
                return null;
            }
            // if we have already received a packet, check if another is available.
            if (transfers > 0) {
                // Determine if Peer will send us data or has no data to send us
                final Response dataAvailableCode = readTransactionResponse();
                switch(dataAvailableCode.getCode()) {
                    case CONTINUE_TRANSACTION:
                        logger.debug("{} {} Indicates Transaction should continue", this, peer);
                        this.dataAvailable = true;
                        break;
                    case FINISH_TRANSACTION:
                        logger.debug("{} {} Indicates Transaction should finish", this, peer);
                        this.dataAvailable = false;
                        break;
                    default:
                        throw new ProtocolException("Got unexpected response from " + peer + " when asking for data: " + dataAvailableCode);
                }
            }
            // if no data available, return null
            if (!dataAvailable) {
                return null;
            }
            logger.debug("{} Receiving data from {}", this, peer);
            final InputStream is = peer.getCommunicationsSession().getInput().getInputStream();
            final InputStream dataIn = compress ? new CompressionInputStream(is) : is;
            final DataPacket packet = codec.decode(new CheckedInputStream(dataIn, crc));
            if (packet == null) {
                this.dataAvailable = false;
            } else {
                transfers++;
                contentBytes += packet.getSize();
            }
            this.state = TransactionState.DATA_EXCHANGED;
            return packet;
        } catch (final IOException ioe) {
            throw new IOException("Failed to receive data from " + peer + " due to " + ioe, ioe);
        }
    } catch (final Exception e) {
        error();
        throw e;
    }
}

Example 12 with Response

use of org.apache.nifi.remote.protocol.Response in project nifi by apache.

the class AbstractTransaction method confirm.

@Override
public final void confirm() throws IOException {
    try {
        try {
            if (state == TransactionState.TRANSACTION_STARTED && !dataAvailable && direction == TransferDirection.RECEIVE) {
                // client requested to receive data but no data available. no need to confirm.
                state = TransactionState.TRANSACTION_CONFIRMED;
                return;
            }
            if (state != TransactionState.DATA_EXCHANGED) {
                throw new IllegalStateException("Cannot confirm Transaction because state is " + state + "; Transaction can only be confirmed when state is " + TransactionState.DATA_EXCHANGED);
            }
            final CommunicationsSession commsSession = peer.getCommunicationsSession();
            if (direction == TransferDirection.RECEIVE) {
                if (dataAvailable) {
                    throw new IllegalStateException("Cannot complete transaction because the sender has already sent more data than client has consumed.");
                }
                // we received a FINISH_TRANSACTION indicator. Send back a CONFIRM_TRANSACTION message
                // to peer so that we can verify that the connection is still open. This is a two-phase commit,
                // which helps to prevent the chances of data duplication. Without doing this, we may commit the
                // session and then when we send the response back to the peer, the peer may have timed out and may not
                // be listening. As a result, it will re-send the data. By doing this two-phase commit, we narrow the
                // Critical Section involved in this transaction so that rather than the Critical Section being the
                // time window involved in the entire transaction, it is reduced to a simple round-trip conversation.
                logger.trace("{} Sending CONFIRM_TRANSACTION Response Code to {}", this, peer);
                final String calculatedCRC = String.valueOf(crc.getValue());
                writeTransactionResponse(ResponseCode.CONFIRM_TRANSACTION, calculatedCRC);
                final Response confirmTransactionResponse;
                try {
                    confirmTransactionResponse = readTransactionResponse();
                } catch (final IOException ioe) {
                    logger.error("Failed to receive response code from {} when expecting confirmation of transaction", peer);
                    if (eventReporter != null) {
                        eventReporter.reportEvent(Severity.ERROR, "Site-to-Site", "Failed to receive response code from " + peer + " when expecting confirmation of transaction");
                    }
                    throw ioe;
                }
                logger.trace("{} Received {} from {}", this, confirmTransactionResponse, peer);
                switch(confirmTransactionResponse.getCode()) {
                    case CONFIRM_TRANSACTION:
                        break;
                    case BAD_CHECKSUM:
                        throw new IOException(this + " Received a BadChecksum response from peer " + peer);
                    default:
                        throw new ProtocolException(this + " Received unexpected Response from peer " + peer + " : " + confirmTransactionResponse + "; expected 'Confirm Transaction' Response Code");
                }
                state = TransactionState.TRANSACTION_CONFIRMED;
            } else {
                logger.debug("{} Sent FINISH_TRANSACTION indicator to {}", this, peer);
                writeTransactionResponse(ResponseCode.FINISH_TRANSACTION);
                final String calculatedCRC = String.valueOf(crc.getValue());
                // we've sent a FINISH_TRANSACTION. Now we'll wait for the peer to send a 'Confirm Transaction' response
                final Response transactionConfirmationResponse = readTransactionResponse();
                if (transactionConfirmationResponse.getCode() == ResponseCode.CONFIRM_TRANSACTION) {
                    // Confirm checksum and echo back the confirmation.
                    logger.trace("{} Received {} from {}", this, transactionConfirmationResponse, peer);
                    final String receivedCRC = transactionConfirmationResponse.getMessage();
                    // CRC was not used before version 4
                    if (protocolVersion > 3) {
                        if (!receivedCRC.equals(calculatedCRC)) {
                            writeTransactionResponse(ResponseCode.BAD_CHECKSUM);
                            throw new IOException(this + " Sent data to peer " + peer + " but calculated CRC32 Checksum as " + calculatedCRC + " while peer calculated CRC32 Checksum as " + receivedCRC + "; canceling transaction and rolling back session");
                        }
                    }
                    writeTransactionResponse(ResponseCode.CONFIRM_TRANSACTION, "");
                } else {
                    throw new ProtocolException("Expected to receive 'Confirm Transaction' response from peer " + peer + " but received " + transactionConfirmationResponse);
                }
                state = TransactionState.TRANSACTION_CONFIRMED;
            }
        } catch (final IOException ioe) {
            throw new IOException("Failed to confirm transaction with " + peer + " due to " + ioe, ioe);
        }
    } catch (final Exception e) {
        error();
        throw e;
    }
}

Example 13 with Response

use of org.apache.nifi.remote.protocol.Response in project nifi by apache.

the class AbstractTransaction method complete.

@Override
public final TransactionCompletion complete() throws IOException {
    try {
        try {
            if (state != TransactionState.TRANSACTION_CONFIRMED) {
                throw new IllegalStateException("Cannot complete transaction with " + peer + " because state is " + state + "; Transaction can only be completed when state is " + TransactionState.TRANSACTION_CONFIRMED);
            }
            boolean backoff = false;
            if (direction == TransferDirection.RECEIVE) {
                if (transfers == 0) {
                    state = TransactionState.TRANSACTION_COMPLETED;
                    return new ClientTransactionCompletion(false, 0, 0L, System.nanoTime() - creationNanoTime);
                }
                // Confirm that we received the data and the peer can now discard it
                logger.debug("{} Sending TRANSACTION_FINISHED to {}", this, peer);
                writeTransactionResponse(ResponseCode.TRANSACTION_FINISHED);
                state = TransactionState.TRANSACTION_COMPLETED;
            } else {
                final Response transactionResponse;
                try {
                    transactionResponse = readTransactionResponse();
                } catch (final IOException e) {
                    throw new IOException(this + " Failed to receive a response from " + peer + " when expecting a TransactionFinished Indicator. " + "It is unknown whether or not the peer successfully received/processed the data. " + e, e);
                }
                logger.debug("{} Received {} from {}", this, transactionResponse, peer);
                if (transactionResponse.getCode() == ResponseCode.TRANSACTION_FINISHED_BUT_DESTINATION_FULL) {
                    peer.penalize(destinationId, penaltyMillis);
                    backoff = true;
                } else if (transactionResponse.getCode() != ResponseCode.TRANSACTION_FINISHED) {
                    throw new ProtocolException("After sending data to " + peer + ", expected TRANSACTION_FINISHED response but got " + transactionResponse);
                }
                state = TransactionState.TRANSACTION_COMPLETED;
            }
            return new ClientTransactionCompletion(backoff, transfers, contentBytes, System.nanoTime() - creationNanoTime);
        } catch (final IOException ioe) {
            throw new IOException("Failed to complete transaction with " + peer + " due to " + ioe, ioe);
        }
    } catch (final Exception e) {
        error();
        throw e;
    } finally {
        close();
    }
}