public DataTransferResource(final NiFiProperties nifiProperties){ this.nifiProperties = nifiProperties; transactionManager = HttpRemoteSiteListener.getInstance(nifiProperties); }
@Override public void start() throws IOException { transactionMaintenanceTask = taskExecutor.scheduleWithFixedDelay(() -> { int originalSize = transactions.size(); logger.trace("Transaction maintenance task started."); try { Set<String> transactionIds = transactions.keySet().stream().collect(Collectors.toSet()); transactionIds.stream().filter(tid -> !isTransactionActive(tid)) .forEach(tid -> cancelTransaction(tid)); } catch (Exception e) { // Swallow exception so that this thread can keep working. logger.error("An exception occurred while maintaining transactions", e); } logger.debug("Transaction maintenance task finished. originalSize={}, currentSize={}", originalSize, transactions.size()); }, 0, transactionTtlSec / 2, TimeUnit.SECONDS); }
public static HttpRemoteSiteListener getInstance(final NiFiProperties nifiProperties) { if (instance == null) { synchronized (HttpRemoteSiteListener.class) { if (instance == null) { instance = new HttpRemoteSiteListener(nifiProperties); } } } return instance; }
public boolean isTransactionActive(final String transactionId) { TransactionWrapper transaction = transactions.get(transactionId); return isTransactionActive(transaction); }
private HttpFlowFileServerProtocol initiateServerProtocol(final HttpServletRequest req, final Peer peer, final Integer transportProtocolVersion) throws IOException { // Switch transaction protocol version based on transport protocol version. TransportProtocolVersionNegotiator negotiatedTransportProtocolVersion = new TransportProtocolVersionNegotiator(transportProtocolVersion); VersionNegotiator versionNegotiator = new StandardVersionNegotiator(negotiatedTransportProtocolVersion.getTransactionProtocolVersion()); final String dataTransferUrl = req.getRequestURL().toString(); ((HttpCommunicationsSession)peer.getCommunicationsSession()).setDataTransferUrl(dataTransferUrl); HttpFlowFileServerProtocol serverProtocol = getHttpFlowFileServerProtocol(versionNegotiator); HttpRemoteSiteListener.getInstance(nifiProperties).setupServerProtocol(serverProtocol); serverProtocol.handshake(peer); return serverProtocol; }
final String transactionId = transactionManager.createTransaction(); final Peer peer = constructPeer(req, inputStream, out, portId, transactionId); final int transportProtocolVersion = validationResult.transportProtocolVersion; transactionManager.cancelTransaction(transactionId); return responseCreator.handshakeExceptionResponse(e); transactionManager.cancelTransaction(transactionId); return responseCreator.unexpectedErrorResponse(portId, e);
private Response cancelTransaction(String transactionId, TransactionResultEntity entity) { transactionManager.cancelTransaction(transactionId); entity.setMessage("Transaction has been canceled."); entity.setResponseCode(ResponseCode.CANCEL_TRANSACTION.getCode()); return Response.ok(entity).build(); }
@Override public int commitReceiveTransaction(Peer peer) throws IOException, IllegalStateException { logger.debug("{} Committing the receive transaction. peer={}", this, peer); HttpServerCommunicationsSession commSession = (HttpServerCommunicationsSession) peer.getCommunicationsSession(); String transactionId = commSession.getTransactionId(); FlowFileTransaction transaction = transactionManager.finalizeTransaction(transactionId); commSession.setStatus(Transaction.TransactionState.TRANSACTION_CONFIRMED); return super.commitReceiveTransaction(peer, transaction); }
@Override protected HandshakeProperties doHandshake(Peer peer) throws IOException, HandshakeException { HttpServerCommunicationsSession commsSession = (HttpServerCommunicationsSession) peer.getCommunicationsSession(); final String transactionId = commsSession.getTransactionId(); HandshakeProperties confirmed = null; if (!StringUtils.isEmpty(transactionId)) { // If handshake is already done, use it. confirmed = transactionManager.getHandshakenProperties(transactionId); } if (confirmed == null) { // If it's not, then do handshake. confirmed = new HandshakeProperties(); confirmed.setCommsIdentifier(transactionId); validateHandshakeRequest(confirmed, peer, commsSession.getHandshakeParams()); } logger.debug("{} Done handshake, confirmed={}", this, confirmed); return confirmed; }
protected Response.ResponseBuilder setCommonHeaders(final Response.ResponseBuilder builder, final Integer transportProtocolVersion, final HttpRemoteSiteListener transactionManager) { return builder.header(HttpHeaders.PROTOCOL_VERSION, transportProtocolVersion) .header(HttpHeaders.SERVER_SIDE_TRANSACTION_TTL, transactionManager.getTransactionTtlSec()); }
transactionManager.extendTransaction(transactionId);
/** * @param transactionId transactionId to check * @return Returns a HandshakeProperties instance which is created when this * transaction is started, only if the transaction is active, and it holds a * HandshakeProperties, otherwise return null */ public HandshakeProperties getHandshakenProperties(final String transactionId) { TransactionWrapper transaction = transactions.get(transactionId); if (isTransactionActive(transaction)) { return transaction.handshakeProperties; } return null; }
@Override public int commitTransferTransaction(Peer peer, String clientChecksum) throws IOException, IllegalStateException { logger.debug("{} Committing the transfer transaction. peer={} clientChecksum={}", this, peer, clientChecksum); HttpServerCommunicationsSession commSession = (HttpServerCommunicationsSession) peer.getCommunicationsSession(); String transactionId = commSession.getTransactionId(); FlowFileTransaction transaction = transactionManager.finalizeTransaction(transactionId); commSession.setChecksum(clientChecksum); commSession.setStatus(Transaction.TransactionState.DATA_EXCHANGED); return super.commitTransferTransaction(peer, transaction); }
@Override protected HandshakeProperties doHandshake(Peer peer) throws IOException, HandshakeException { HttpServerCommunicationsSession commsSession = (HttpServerCommunicationsSession) peer.getCommunicationsSession(); final String transactionId = commsSession.getTransactionId(); HandshakeProperties confirmed = null; if (!StringUtils.isEmpty(transactionId)) { // If handshake is already done, use it. confirmed = transactionManager.getHandshakenProperties(transactionId); } if (confirmed == null) { // If it's not, then do handshake. confirmed = new HandshakeProperties(); confirmed.setCommsIdentifier(transactionId); validateHandshakeRequest(confirmed, peer, commsSession.getHandshakeParams()); } logger.debug("{} Done handshake, confirmed={}", this, confirmed); return confirmed; }
public StandardHttpFlowFileServerProtocol(final VersionNegotiator versionNegotiator, final NiFiProperties nifiProperties) { super(); this.versionNegotiator = versionNegotiator; this.transactionManager = HttpRemoteSiteListener.getInstance(nifiProperties); }
public void extendTransaction(final String transactionId) throws IllegalStateException { if (!isTransactionActive(transactionId)) { throw new IllegalStateException("Transaction was not found or not active anymore. transactionId=" + transactionId); } TransactionWrapper transaction = transactions.get(transactionId); if (transaction != null) { logger.debug("Extending transaction TTL, transactionId={}", transactionId); transaction.extend(); } }
@Override public void start() throws IOException { transactionMaintenanceTask = taskExecutor.scheduleWithFixedDelay(() -> { int originalSize = transactions.size(); logger.trace("Transaction maintenance task started."); try { Set<String> transactionIds = transactions.keySet().stream().collect(Collectors.toSet()); transactionIds.stream().filter(tid -> !isTransactionActive(tid)) .forEach(tid -> cancelTransaction(tid)); } catch (Exception e) { // Swallow exception so that this thread can keep working. logger.error("An exception occurred while maintaining transactions", e); } logger.debug("Transaction maintenance task finished. originalSize={}, currentSize={}", originalSize, transactions.size()); }, 0, transactionTtlSec / 2, TimeUnit.SECONDS); }
@Override public int commitReceiveTransaction(Peer peer) throws IOException, IllegalStateException { logger.debug("{} Committing the receive transaction. peer={}", this, peer); HttpServerCommunicationsSession commSession = (HttpServerCommunicationsSession) peer.getCommunicationsSession(); String transactionId = commSession.getTransactionId(); FlowFileTransaction transaction = transactionManager.finalizeTransaction(transactionId); commSession.setStatus(Transaction.TransactionState.TRANSACTION_CONFIRMED); return super.commitReceiveTransaction(peer, transaction); }
public static HttpRemoteSiteListener getInstance(final NiFiProperties nifiProperties) { if (instance == null) { synchronized (HttpRemoteSiteListener.class) { if (instance == null) { instance = new HttpRemoteSiteListener(nifiProperties); } } } return instance; }
public SiteToSiteResource(final NiFiProperties nifiProperties) { transactionManager = HttpRemoteSiteListener.getInstance(nifiProperties); peerDescriptionModifier = new PeerDescriptionModifier(nifiProperties); }