Github user markap14 commented on a diff in the pull request:

    https://github.com/apache/nifi/pull/439#discussion_r63425553
  
    --- Diff: 
nifi-nar-bundles/nifi-framework-bundle/nifi-framework/nifi-framework-core/src/main/java/org/apache/nifi/controller/repository/StandardProcessSession.java
 ---
    @@ -2308,18 +2308,50 @@ public void exportTo(final FlowFile source, final 
Path destination, final boolea
         public void exportTo(final FlowFile source, final OutputStream 
destination) {
             validateRecordState(source);
             final StandardRepositoryRecord record = records.get(source);
    +
    +        if(record.getCurrentClaim() == null) {
    +            return;
    +        }
    +
             try {
    -            if (record.getCurrentClaim() == null) {
    -                return;
    +            ensureNotAppending(record.getCurrentClaim());
    +        } catch (final IOException e) {
    +            throw new FlowFileAccessException("Failed to access 
ContentClaim for " + source.toString(), e);
    +        }
    +
    +        try (final InputStream rawIn = getInputStream(source, 
record.getCurrentClaim(), record.getCurrentClaimOffset());
    +                final InputStream limitedIn = new 
LimitedInputStream(rawIn, source.getSize());
    +                final InputStream disableOnCloseIn = new 
DisableOnCloseInputStream(limitedIn);
    +                final ByteCountingInputStream countingStream = new 
ByteCountingInputStream(disableOnCloseIn, this.bytesRead)) {
    +
    +            // We want to differentiate between IOExceptions thrown by the 
repository and IOExceptions thrown from
    +            // Processor code. As a result, as have the 
FlowFileAccessInputStream that catches IOException from the repository
    +            // and translates into either FlowFileAccessException or 
ContentNotFoundException. We keep track of any
    +            // ContentNotFoundException because if it is thrown, the 
Processor code may catch it and do something else with it
    +            // but in reality, if it is thrown, we want to know about it 
and handle it, even if the Processor code catches it.
    +            final FlowFileAccessInputStream ffais = new 
FlowFileAccessInputStream(countingStream, source, record.getCurrentClaim());
    +            boolean cnfeThrown = false;
    +
    +            try {
    +                recursionSet.add(source);
    +                StreamUtils.skip(ffais, record.getCurrentClaimOffset());
    +                StreamUtils.copy(ffais, destination, source.getSize());
    +            } catch (final ContentNotFoundException cnfe) {
    +                cnfeThrown = true;
    +                throw cnfe;
    +            } finally {
    +                recursionSet.remove(source);
    +                IOUtils.closeQuietly(ffais);
    +                // if cnfeThrown is true, we don't need to re-thrown the 
Exception; it will propagate.
    --- End diff --
    
    i think the comment here is supposed to see "need to re-throw" rather than 
"need to re-thrown"


---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastruct...@apache.org or file a JIRA ticket
with INFRA.
---

Reply via email to