You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@nifi.apache.org by ma...@apache.org on 2017/11/13 19:45:05 UTC
[2/3] nifi git commit: groovyx initial version
http://git-wip-us.apache.org/repos/asf/nifi/blob/c7a5a09b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/flow/ProcessSessionWrap.java
----------------------------------------------------------------------
diff --git a/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/flow/ProcessSessionWrap.java b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/flow/ProcessSessionWrap.java
new file mode 100644
index 0000000..82ade43
--- /dev/null
+++ b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/flow/ProcessSessionWrap.java
@@ -0,0 +1,969 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.nifi.processors.groovyx.flow;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import org.apache.nifi.controller.queue.QueueSize;
+import org.apache.nifi.flowfile.FlowFile;
+import org.apache.nifi.processor.FlowFileFilter;
+import org.apache.nifi.processor.ProcessSession;
+import org.apache.nifi.processor.Relationship;
+import org.apache.nifi.processor.exception.FlowFileAccessException;
+import org.apache.nifi.processor.exception.FlowFileHandlingException;
+import org.apache.nifi.processor.exception.MissingFlowFileException;
+import org.apache.nifi.processor.exception.ProcessException;
+import org.apache.nifi.processor.io.InputStreamCallback;
+import org.apache.nifi.processor.io.OutputStreamCallback;
+import org.apache.nifi.processor.io.StreamCallback;
+import org.apache.nifi.provenance.ProvenanceReporter;
+
+import org.apache.nifi.processors.groovyx.util.Throwables;
+
+/**
+ * wrapped session that collects all created/modified files if created with special flag
+ * and able to execute method revertReceivedTo(Relationship r, Throwable t)
+ * it will be good to create functionality with created file list and received file list in a standard session.
+ * Those file lists will simplify error management.
+ */
+public abstract class ProcessSessionWrap implements ProcessSession {
+
+ public static final String ERROR_STACKTRACE = "ERROR_STACKTRACE";
+ public static final String ERROR_MESSAGE = "ERROR_MESSAGE";
+ private ProcessSession s;
+ private boolean foe;
+
+ /*
+ list of files to be sent to failure on error
+ on get() we will store here clone
+ */
+ private List<FlowFile> toFail = new ArrayList<>();
+
+ /*
+ list of files to be dropped on error
+ on get(),create(),write(),... we will store here last version of file by id
+ */
+ private Map<String, FlowFile> toDrop = new HashMap<>();
+
+ public ProcessSessionWrap(ProcessSession s, boolean toFailureOnError) {
+ if (s instanceof ProcessSessionWrap) {
+ throw new RuntimeException("session could be instanceof ProcessSessionWrap");
+ }
+ if (s == null) {
+ throw new NullPointerException("Session is mandatory session=null");
+ }
+ this.s = s;
+ foe = toFailureOnError;
+ }
+
+ /**
+ * function returns wrapped flowfile with session for the simplified script access.
+ * The sample implementation: <code>
+ * public SessionFile wrap(FlowFile f) {
+ * if (f == null) {
+ * return null;
+ * }
+ * if (f instanceof SessionFile) {
+ * return ((SessionFile) f);
+ * }
+ * return new SessionFile(this, f);
+ * }</code>
+ */
+ public abstract SessionFile wrap(FlowFile f);
+
+ public List<FlowFile> wrap(List ff) {
+ if (ff == null) {
+ return null;
+ }
+ for (int i = 0; i < ff.size(); i++) {
+ ff.set(i, wrap((FlowFile) ff.get(i)));
+ }
+ return ff;
+ }
+
+ public FlowFile unwrap(FlowFile f) {
+ if (f == null) {
+ return null;
+ }
+ if (f instanceof SessionFile) {
+ return ((SessionFile) f).flowFile;
+ }
+ return f;
+ }
+
+ public List<FlowFile> unwrap(Collection<FlowFile> _ff) {
+ if (_ff == null) {
+ return null;
+ }
+ List<FlowFile> ff = new ArrayList(_ff);
+ for (int i = 0; i < ff.size(); i++) {
+ ff.set(i, unwrap(ff.get(i)));
+ }
+ return ff;
+ }
+
+ private void assertNotSessionFile(FlowFile f) {
+ if (f instanceof SessionFile) {
+ throw new RuntimeException("SessionFile not accepted at this point. " + this.getClass() + " developer failure.");
+ }
+ }
+
+ /**
+ * called when file created or modified
+ */
+ private FlowFile onMod(FlowFile f) {
+ assertNotSessionFile(f);
+ if (foe) {
+ toDrop.put(f.getAttribute("uuid"), f);
+ }
+ return f;
+ }
+
+ /**
+ * called when got file from incoming queue
+ */
+ private FlowFile onGet(FlowFile f) {
+ assertNotSessionFile(f);
+ if (f == null) {
+ return null;
+ }
+ if (foe) {
+ toFail.add(s.clone(f));
+ onMod(f);
+ }
+ return f;
+ }
+
+ private List<FlowFile> onGet(List<FlowFile> ff) {
+ if (ff == null) {
+ return null;
+ }
+ if (foe) {
+ for (FlowFile f : ff) {
+ onGet(f);
+ }
+ }
+ return ff;
+ }
+
+ /**
+ * called when the file removed
+ */
+ private void onDrop(FlowFile f) {
+ assertNotSessionFile(f);
+ if (foe) {
+ toDrop.remove(f.getAttribute("uuid"));
+ }
+ }
+
+ private void onDrop(Collection<FlowFile> ff) {
+ if (foe) {
+ for (FlowFile f : ff) {
+ onDrop(f);
+ }
+ }
+ }
+
+ private void onClear() {
+ if (foe) {
+ toDrop.clear();
+ toFail.clear();
+ }
+ }
+
+ /**
+ * transfers all input files to relationship and drops other files.
+ *
+ * @param r where to transfer flow files, when null then transfers to input with penalize.
+ * @param t the cause why we do this transfer, when relationship specified then additional properties populated: ERROR_MESSAGE and ERROR_STACKTRACE.
+ */
+ public void revertReceivedTo(Relationship r, Throwable t) {
+ for (FlowFile f : toDrop.values()) {
+ s.remove(f);
+ }
+ String errorMessage = Throwables.getMessage(t, null, 950);
+ String stackTrace = Throwables.stringStackTrace(t);
+ for (FlowFile f : toFail) {
+ if (t != null && r != null) {
+ f = s.putAttribute(f, ERROR_MESSAGE, errorMessage);
+ f = s.putAttribute(f, ERROR_STACKTRACE, stackTrace);
+ }
+ if (r != null) {
+ s.transfer(f, r);
+ } else {
+ f = s.penalize(f);
+ s.transfer(f);
+ }
+ }
+ s.commit();
+ onClear();
+ }
+ /*============================================= NATIVE METHODS ================================================*/
+
+ /**
+ * <p>
+ * Commits the current session ensuring all operations against FlowFiles
+ * within this session are atomically persisted. All FlowFiles operated on
+ * within this session must be accounted for by transfer or removal or the
+ * commit will fail.
+ * </p>
+ * <p>
+ * <p>
+ * As soon as the commit completes the session is again ready to be used
+ * </p>
+ *
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session.
+ * @throws FlowFileHandlingException if not all FlowFiles acted upon within this session are accounted for by user code such that they have a transfer identified or where marked for removal.
+ * Automated rollback occurs.
+ * @throws ProcessException if some general fault occurs while persisting the session. Initiates automatic rollback. The root cause can be obtained via <code>Exception.getCause()</code>
+ */
+ @Override
+ public void commit() {
+ for (FlowFile f : toFail) {
+ s.remove(f);
+ }
+ s.commit();
+ onClear();
+ }
+
+ /**
+ * Reverts any changes made during this session. All FlowFiles are restored
+ * back to their initial session state and back to their original queues. If
+ * this session is already committed or rolled back then no changes will
+ * occur. This method can be called any number of times. Calling this method
+ * is identical to calling {@link #rollback(boolean)} passing
+ * <code>false</code> as the parameter.
+ */
+ @Override
+ public void rollback() {
+ s.rollback();
+ onClear();
+ }
+
+ /**
+ * Reverts any changes made during this session. All FlowFiles are restored
+ * back to their initial session state and back to their original queues,
+ * after optionally being penalized. If this session is already committed or
+ * rolled back then no changes will occur. This method can be called any
+ * number of times.
+ *
+ * @param penalize whether or not the FlowFiles that are being restored back to their queues should be penalized
+ */
+ @Override
+ public void rollback(boolean penalize) {
+ s.rollback(penalize);
+ onClear();
+ }
+
+ /**
+ * Adjusts counter data for the given counter name and takes care of
+ * registering the counter if not already present. The adjustment occurs
+ * only if and when the ProcessSession is committed.
+ *
+ * @param name the name of the counter
+ * @param delta the delta by which to modify the counter (+ or -)
+ * @param immediate if true, the counter will be updated immediately, without regard to whether the ProcessSession is commit or rolled back; otherwise, the counter will be incremented only if and
+ * when the ProcessSession is committed.
+ */
+ @Override
+ public void adjustCounter(String name, long delta, boolean immediate) {
+ s.adjustCounter(name, delta, immediate);
+ }
+
+ /**
+ * @return FlowFile that is next highest priority FlowFile to process. Otherwise returns null.
+ */
+ @Override
+ public SessionFile get() {
+ return wrap(onGet(s.get()));
+ }
+
+ /**
+ * Returns up to <code>maxResults</code> FlowFiles from the work queue. If
+ * no FlowFiles are available, returns an empty list. Will not return null.
+ * If multiple incoming queues are present, the behavior is unspecified in
+ * terms of whether all queues or only a single queue will be polled in a
+ * single call.
+ *
+ * @param maxResults the maximum number of FlowFiles to return
+ * @return up to <code>maxResults</code> FlowFiles from the work queue. If no FlowFiles are available, returns an empty list. Will not return null.
+ * @throws IllegalArgumentException if <code>maxResults</code> is less than 0
+ */
+ @Override
+ public List<FlowFile> get(int maxResults) {
+ return wrap(onGet(s.get(maxResults)));
+ }
+
+ /**
+ * <p>
+ * Returns all FlowFiles from all of the incoming queues for which the given
+ * {@link FlowFileFilter} indicates should be accepted. Calls to this method
+ * provide exclusive access to the underlying queues. I.e., no other thread
+ * will be permitted to pull FlowFiles from this Processor's queues or add
+ * FlowFiles to this Processor's incoming queues until this method call has
+ * returned.
+ * </p>
+ *
+ * @param filter to limit which flow files are returned
+ * @return all FlowFiles from all of the incoming queues for which the given {@link FlowFileFilter} indicates should be accepted.
+ */
+ @Override
+ public List<FlowFile> get(FlowFileFilter filter) {
+ return wrap(onGet(s.get(filter)));
+ }
+
+ /**
+ * @return the QueueSize that represents the number of FlowFiles and their combined data size for all FlowFiles waiting to be processed by the Processor that owns this ProcessSession, regardless
+ * of which Connection the FlowFiles live on
+ */
+ @Override
+ public QueueSize getQueueSize() {
+ return s.getQueueSize();
+ }
+
+ /**
+ * Creates a new FlowFile in the repository with no content and without any
+ * linkage to a parent FlowFile. This method is appropriate only when data
+ * is received or created from an external system. Otherwise, this method
+ * should be avoided and should instead use {@link #create(FlowFile)} or
+ * {@see #create(Collection)}.
+ * <p>
+ * When this method is used, a Provenance CREATE or RECEIVE Event should be
+ * generated. See the {@link #getProvenanceReporter()} method and
+ * {@link ProvenanceReporter} class for more information
+ *
+ * @return newly created FlowFile
+ */
+ @Override
+ public SessionFile create() {
+ return wrap(onMod(s.create()));
+ }
+
+ /**
+ * Creates a new FlowFile in the repository with no content but with a
+ * parent linkage to <code>parent</code>. The newly created FlowFile will
+ * inherit all of the parent's attributes except for the UUID. This method
+ * will automatically generate a Provenance FORK event or a Provenance JOIN
+ * event, depending on whether or not other FlowFiles are generated from the
+ * same parent before the ProcessSession is committed.
+ *
+ * @param parent to base the new flowfile on
+ * @return newly created flowfile
+ */
+ @Override
+ public SessionFile create(FlowFile parent) {
+ return wrap(onMod(s.create(unwrap(parent))));
+ }
+
+ /**
+ * Creates a new FlowFile in the repository with no content but with a
+ * parent linkage to the FlowFiles specified by the parents Collection. The
+ * newly created FlowFile will inherit all of the attributes that are in
+ * common to all parents (except for the UUID, which will be in common if
+ * only a single parent exists). This method will automatically generate a
+ * Provenance JOIN event.
+ *
+ * @param parents which the new flowfile should inherit shared attributes from
+ * @return new flowfile
+ */
+ @Override
+ public SessionFile create(Collection<FlowFile> parents) {
+ return wrap(onMod(s.create(unwrap(parents))));
+ }
+
+ /**
+ * Creates a new FlowFile that is a clone of the given FlowFile as of the
+ * time this is called, both in content and attributes. This method
+ * automatically emits a Provenance CLONE Event.
+ *
+ * @param example FlowFile to be the source of cloning - given FlowFile must be a part of the given session
+ * @return FlowFile that is a clone of the given example
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be reference, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ * @throws FlowFileAccessException if some IO problem occurs accessing FlowFile content
+ * @throws NullPointerException if the argument null
+ */
+ @Override
+ public SessionFile clone(FlowFile example) {
+ return wrap(onMod(s.clone(unwrap(example))));
+ }
+
+ /**
+ * Creates a new FlowFile whose parent is the given FlowFile. The content of
+ * the new FlowFile will be a subset of the byte sequence of the given
+ * FlowFile starting at the specified offset and with the length specified.
+ * The new FlowFile will contain all of the attributes of the original. This
+ * method automatically emits a Provenance FORK Event (or a Provenance CLONE
+ * Event, if the offset is 0 and the size is exactly equal to the size of
+ * the example FlowFile).
+ *
+ * @param parent to base the new flowfile attributes on
+ * @param offset of the parent flowfile to base the child flowfile content on
+ * @param size of the new flowfile from the offset
+ * @return a FlowFile with the specified size whose parent is first argument to this function
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session, or if the specified offset + size exceeds that of the size of the
+ * parent FlowFile. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be reference, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ */
+ @Override
+ public SessionFile clone(FlowFile parent, long offset, long size) {
+ return wrap(onMod(s.clone(unwrap(parent), offset, size)));
+ }
+
+ /**
+ * Sets a penalty for the given FlowFile which will make it unavailable to
+ * be operated on any further during the penalty period.
+ *
+ * @param flowFile to penalize
+ * @return FlowFile the new FlowFile reference to use
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws NullPointerException if the argument null
+ */
+ @Override
+ public SessionFile penalize(FlowFile flowFile) {
+ SessionFile sf = wrap(flowFile);
+ sf.flowFile = onMod(s.penalize(sf.flowFile));
+ return sf;
+ }
+
+ /**
+ * Updates the given FlowFiles attributes with the given key/value pair. If
+ * the key is named {@code uuid}, this attribute will be ignored.
+ *
+ * @param flowFile to update
+ * @param key of attribute
+ * @param value of attribute
+ * @return FlowFile the updated FlowFile
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws NullPointerException if an argument is null
+ */
+ @Override
+ public SessionFile putAttribute(FlowFile flowFile, String key, String value) {
+ SessionFile sf = wrap(flowFile);
+ sf.flowFile = onMod(s.putAttribute(sf.flowFile, key, value));
+ return sf;
+ }
+
+ /**
+ * Updates the given FlowFiles attributes with the given key/value pairs. If
+ * the map contains a key named {@code uuid}, this attribute will be
+ * ignored.
+ *
+ * @param flowFile to update
+ * @param attributes the attributes to add to the given FlowFile
+ * @return FlowFile the updated FlowFile
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws NullPointerException if an argument is null
+ */
+ @Override
+ public SessionFile putAllAttributes(FlowFile flowFile, Map<String, String> attributes) {
+ SessionFile sf = wrap(flowFile);
+ sf.flowFile = onMod(s.putAllAttributes(sf.flowFile, attributes));
+ return sf;
+ }
+
+ /**
+ * Removes the given FlowFile attribute with the given key. If the key is
+ * named {@code uuid}, this method will return the same FlowFile without
+ * removing any attribute.
+ *
+ * @param flowFile to update
+ * @param key of attribute
+ * @return FlowFile the updated FlowFile
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws NullPointerException if the argument null
+ */
+ @Override
+ public SessionFile removeAttribute(FlowFile flowFile, String key) {
+ SessionFile sf = wrap(flowFile);
+ sf.flowFile = onMod(s.removeAttribute(sf.flowFile, key));
+ return sf;
+ }
+
+ /**
+ * Removes the attributes with the given keys from the given FlowFile. If
+ * the set of keys contains the value {@code uuid}, this key will be ignored
+ *
+ * @param flowFile to update
+ * @param keys of attribute
+ * @return FlowFile the updated FlowFile
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws NullPointerException if the argument null
+ */
+ @Override
+ public SessionFile removeAllAttributes(FlowFile flowFile, Set<String> keys) {
+ SessionFile sf = wrap(flowFile);
+ sf.flowFile = onMod(s.removeAllAttributes(sf.flowFile, keys));
+ return sf;
+ }
+
+ /**
+ * Remove all attributes from the given FlowFile that have keys which match
+ * the given pattern. If the pattern matches the key {@code uuid}, this key
+ * will not be removed.
+ *
+ * @param flowFile to update
+ * @param keyPattern may be null; if supplied is matched against each of the FlowFile attribute keys
+ * @return FlowFile containing only attributes which did not meet the key pattern
+ */
+ @Override
+ public SessionFile removeAllAttributes(FlowFile flowFile, Pattern keyPattern) {
+ SessionFile sf = wrap(flowFile);
+ sf.flowFile = onMod(s.removeAllAttributes(sf.flowFile, keyPattern));
+ return sf;
+ }
+
+ /**
+ * Transfers the given FlowFile to the appropriate destination processor
+ * work queue(s) based on the given relationship. If the relationship leads
+ * to more than one destination the state of the FlowFile is replicated such
+ * that each destination receives an exact copy of the FlowFile though each
+ * will have its own unique identity. The destination processors will not be
+ * able to operate on the given FlowFile until this session is committed or
+ * until the ownership of the session is migrated to another processor. If
+ * ownership of the session is passed to a destination processor then that
+ * destination processor will have immediate visibility of the transferred
+ * FlowFiles within the session.
+ *
+ * @param flowFile to transfer
+ * @param relationship to transfer to
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws NullPointerException if the argument null
+ * @throws IllegalArgumentException if given relationship is not a known or registered relationship
+ */
+ @Override
+ public void transfer(FlowFile flowFile, Relationship relationship) {
+ flowFile = unwrap(flowFile);
+ s.transfer(flowFile, relationship);
+ }
+
+ /**
+ * Transfers the given FlowFile back to the work queue from which it was
+ * pulled. The processor will not be able to operate on the given FlowFile
+ * until this session is committed. Any modifications that have been made to
+ * the FlowFile will be maintained. FlowFiles that are created by the
+ * processor cannot be transferred back to themselves via this method.
+ *
+ * @param flowFile to transfer
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws IllegalArgumentException if the FlowFile was created by this processor
+ * @throws NullPointerException if the argument null
+ */
+ @Override
+ public void transfer(FlowFile flowFile) {
+ flowFile = unwrap(flowFile);
+ s.transfer(flowFile);
+ }
+
+ /**
+ * Transfers the given FlowFiles back to the work queues from which the
+ * FlowFiles were pulled. The processor will not be able to operate on the
+ * given FlowFile until this session is committed. Any modifications that
+ * have been made to the FlowFile will be maintained. FlowFiles that are
+ * created by the processor cannot be transferred back to themselves via
+ * this method.
+ *
+ * @param flowFiles to transfer
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFiles are already transferred or removed or don't belong to this session. Automatic rollback will occur.
+ * @throws IllegalArgumentException if the FlowFile was created by this processor
+ * @throws NullPointerException if the argument null
+ */
+ @Override
+ public void transfer(Collection<FlowFile> flowFiles) {
+ flowFiles = unwrap(flowFiles);
+ s.transfer(flowFiles);
+ }
+
+ /**
+ * Transfers the given FlowFile to the appropriate destination processor
+ * work queue(s) based on the given relationship. If the relationship leads
+ * to more than one destination the state of the FlowFile is replicated such
+ * that each destination receives an exact copy of the FlowFile though each
+ * will have its own unique identity. The destination processors will not be
+ * able to operate on the given FlowFile until this session is committed or
+ * until the ownership of the session is migrated to another processor. If
+ * ownership of the session is passed to a destination processor then that
+ * destination processor will have immediate visibility of the transferred
+ * FlowFiles within the session.
+ *
+ * @param flowFiles to transfer
+ * @param relationship to transfer to
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws NullPointerException if the argument null
+ * @throws IllegalArgumentException if given relationship is not a known or registered relationship
+ */
+ @Override
+ public void transfer(Collection<FlowFile> flowFiles, Relationship relationship) {
+ flowFiles = unwrap(flowFiles);
+ s.transfer(flowFiles, relationship);
+ }
+
+ /**
+ * Ends the managed persistence for the given FlowFile. The persistent
+ * attributes for the FlowFile are deleted and so is the content assuming
+ * nothing else references it and this FlowFile will no longer be available
+ * for further operation.
+ *
+ * @param flowFile to remove
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ */
+ @Override
+ public void remove(FlowFile flowFile) {
+ flowFile = unwrap(flowFile);
+ s.remove(flowFile);
+ onDrop(flowFile);
+ }
+
+ /**
+ * Ends the managed persistence for the given FlowFiles. The persistent
+ * attributes for the FlowFile are deleted and so is the content assuming
+ * nothing else references it and this FlowFile will no longer be available
+ * for further operation.
+ *
+ * @param flowFiles to remove
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if any of the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ */
+ @Override
+ public void remove(Collection<FlowFile> flowFiles) {
+ flowFiles = unwrap(flowFiles);
+ s.remove(flowFiles);
+ onDrop(flowFiles);
+ }
+
+ /**
+ * Executes the given callback against the contents corresponding to the
+ * given FlowFile.
+ *
+ * @param flowFile flow file to retrieve content of
+ * @param reader callback that will be called to read the flow file content
+ * @throws FlowFileAccessException if some IO problem occurs accessing FlowFile content; if an attempt is made to access the InputStream provided to the given InputStreamCallback after
+ * this method completed its execution
+ */
+ @Override
+ public void read(FlowFile flowFile, InputStreamCallback reader) throws FlowFileAccessException {
+ flowFile = unwrap(flowFile);
+ s.read(flowFile, reader);
+ }
+
+ /**
+ * Provides an InputStream that can be used to read the contents of the given FlowFile.
+ * This method differs from those that make use of callbacks in that this method returns
+ * an InputStream and expects the caller to properly handle the lifecycle of the InputStream
+ * (i.e., the caller is responsible for ensuring that the InputStream is closed appropriately).
+ * The Process Session may or may not handle closing the stream when {@link #commit()} or {@link #rollback()}
+ * is called, but the responsibility of doing so belongs to the caller. The InputStream will throw
+ * an IOException if an attempt is made to read from the stream after the session is committed or
+ * rolled back.
+ *
+ * @param flowFile the FlowFile to read
+ * @return an InputStream that can be used to read the contents of the FlowFile
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be referenced, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ */
+ @Override
+ public InputStream read(FlowFile flowFile) {
+ flowFile = unwrap(flowFile);
+ return s.read(flowFile);
+ }
+
+ /**
+ * Executes the given callback against the contents corresponding to the
+ * given FlowFile.
+ * <p>
+ * <i>Note</i>: The OutputStream provided to the given OutputStreamCallback
+ * will not be accessible once this method has completed its execution.
+ *
+ * @param flowFile flow file to retrieve content of
+ * @param allowSessionStreamManagement allow session to hold the stream open for performance reasons
+ * @param reader that will be called to read the flow file content
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be reference, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ * @throws FlowFileAccessException if some IO problem occurs accessing FlowFile content; if an attempt is made to access the InputStream provided to the given InputStreamCallback after this
+ * method completed its execution
+ */
+ @Override
+ public void read(FlowFile flowFile, boolean allowSessionStreamManagement, InputStreamCallback reader) throws FlowFileAccessException {
+ flowFile = unwrap(flowFile);
+ s.read(flowFile, allowSessionStreamManagement, reader);
+ }
+
+ /**
+ * Combines the content of all given source FlowFiles into a single given
+ * destination FlowFile.
+ *
+ * @param sources the flowfiles to merge
+ * @param destination the flowfile to use as the merged result
+ * @return updated destination FlowFile (new size, etc...)
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws IllegalArgumentException if the given destination is contained within the sources
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be reference, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ * @throws FlowFileAccessException if some IO problem occurs accessing FlowFile content. The state of the destination will be as it was prior to this call.
+ */
+ @Override
+ public SessionFile merge(Collection<FlowFile> sources, FlowFile destination) {
+ SessionFile sfDestination = wrap(destination);
+ sources = unwrap(sources);
+ sfDestination.flowFile = onMod(s.merge(sources, sfDestination.flowFile));
+ return sfDestination;
+ }
+
+ /**
+ * Combines the content of all given source FlowFiles into a single given
+ * destination FlowFile.
+ *
+ * @param sources to merge together
+ * @param destination to merge to
+ * @param header bytes that will be added to the beginning of the merged output. May be null or empty.
+ * @param footer bytes that will be added to the end of the merged output. May be null or empty.
+ * @param demarcator bytes that will be placed in between each object merged together. May be null or empty.
+ * @return updated destination FlowFile (new size, etc...)
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws IllegalArgumentException if the given destination is contained within the sources
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be reference, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ * @throws FlowFileAccessException if some IO problem occurs accessing FlowFile content. The state of the destination will be as it was prior to this call.
+ */
+ @Override
+ public SessionFile merge(Collection<FlowFile> sources, FlowFile destination, byte[] header, byte[] footer, byte[] demarcator) {
+ SessionFile sfDestination = wrap(destination);
+ sources = unwrap(sources);
+ sfDestination.flowFile = onMod(s.merge(sources, sfDestination.flowFile, header, footer, demarcator));
+ return sfDestination;
+ }
+
+ /**
+ * Executes the given callback against the content corresponding to the
+ * given FlowFile.
+ * <p>
+ * <i>Note</i>: The OutputStream provided to the given OutputStreamCallback
+ * will not be accessible once this method has completed its execution.
+ *
+ * @param flowFile to write to
+ * @param writer used to write new content
+ * @return updated FlowFile
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be referenced, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ * @throws FlowFileAccessException if some IO problem occurs accessing FlowFile content; if an attempt is made to access the OutputStream provided to the given OutputStreamCallback after this
+ * method completed its execution
+ */
+ @Override
+ public SessionFile write(FlowFile flowFile, OutputStreamCallback writer) throws FlowFileAccessException {
+ SessionFile sf = wrap(flowFile);
+ sf.flowFile = onMod(s.write(sf.flowFile, writer));
+ return sf;
+ }
+
+ /**
+ * Executes the given callback against the content corresponding to the
+ * given flow file.
+ * <p>
+ * <i>Note</i>: The InputStream & OutputStream provided to the given
+ * StreamCallback will not be accessible once this method has completed its
+ * execution.
+ *
+ * @param flowFile to read from and write to
+ * @param writer used to read the old content and write new content
+ * @return updated FlowFile
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be reference, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ * @throws FlowFileAccessException if some IO problem occurs accessing FlowFile content; if an attempt is made to access the InputStream or OutputStream provided to the given StreamCallback
+ * after this method completed its execution
+ */
+ @Override
+ public SessionFile write(FlowFile flowFile, StreamCallback writer) throws FlowFileAccessException {
+ SessionFile sf = wrap(flowFile);
+ sf.flowFile = onMod(s.write(sf.flowFile, writer));
+ return sf;
+ }
+
+ /**
+ * Executes the given callback against the content corresponding to the
+ * given FlowFile, such that any data written to the OutputStream of the
+ * content will be appended to the end of FlowFile.
+ * <p>
+ * <i>Note</i>: The OutputStream provided to the given OutputStreamCallback
+ * will not be accessible once this method has completed its execution.
+ *
+ * @param flowFile the flowfile for which content should be appended
+ * @param writer used to write new bytes to the flowfile content
+ * @return the updated flowfile reference for the new content
+ * @throws FlowFileAccessException if an attempt is made to access the OutputStream provided to the given OutputStreamCallback after this method completed its execution
+ */
+ @Override
+ public SessionFile append(FlowFile flowFile, OutputStreamCallback writer) throws FlowFileAccessException {
+ SessionFile sf = wrap(flowFile);
+ sf.flowFile = onMod(s.append(sf.flowFile, writer));
+ return sf;
+ }
+
+ /**
+ * Writes to the given FlowFile all content from the given content path.
+ *
+ * @param source the file from which content will be obtained
+ * @param keepSourceFile if true the content is simply copied; if false the original content might be used in a destructive way for efficiency such that the repository will have the data but the
+ * original data will be gone. If false the source object will be removed or gone once imported. It will not be restored if the session is rolled back
+ * so this must be used with caution. In some cases it can result in tremendous efficiency gains but is also dangerous.
+ * @param flowFile the FlowFile whose content will be updated
+ * @return the updated destination FlowFile (new size)
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be reference, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ * @throws FlowFileAccessException if some IO problem occurs accessing FlowFile content
+ */
+ @Override
+ public SessionFile importFrom(Path source, boolean keepSourceFile, FlowFile flowFile) {
+ SessionFile sf = wrap(flowFile);
+ sf.flowFile = onMod(s.importFrom(source, keepSourceFile, sf.flowFile));
+ return sf;
+ }
+
+ /**
+ * Writes to the given FlowFile all content from the given content path.
+ *
+ * @param source the file from which content will be obtained
+ * @param flowFile the FlowFile whose content will be updated
+ * @return the updated destination FlowFile (new size)
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be reference, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ * @throws FlowFileAccessException if some IO problem occurs accessing FlowFile content
+ */
+ @Override
+ public SessionFile importFrom(InputStream source, FlowFile flowFile) {
+ SessionFile sf = wrap(flowFile);
+ sf.flowFile = onMod(s.importFrom(source, sf.flowFile));
+ return sf;
+ }
+
+ /**
+ * Writes the content of the given FlowFile to the given destination path.
+ *
+ * @param flowFile to export the content of
+ * @param destination to export the content to
+ * @param append if true will append to the current content at the given path; if false will replace any current content
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be reference, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ * @throws FlowFileAccessException if some IO problem occurs accessing FlowFile content
+ */
+ @Override
+ public void exportTo(FlowFile flowFile, Path destination, boolean append) {
+ flowFile = unwrap(flowFile);
+ s.exportTo(flowFile, destination, append);
+ }
+
+ /**
+ * Writes the content of the given FlowFile to the given destination stream
+ *
+ * @param flowFile to export the content of
+ * @param destination to export the content to
+ * @throws IllegalStateException if detected that this method is being called from within a callback of another method in this session and for the given FlowFile(s)
+ * @throws FlowFileHandlingException if the given FlowFile is already transferred or removed or doesn't belong to this session. Automatic rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be found. The FlowFile should no longer be reference, will be internally destroyed, and the session is automatically
+ * rolled back and what is left of the FlowFile is destroyed.
+ * @throws FlowFileAccessException if some IO problem occurs accessing FlowFile content
+ */
+ @Override
+ public void exportTo(FlowFile flowFile, OutputStream destination) {
+ flowFile = unwrap(flowFile);
+ s.exportTo(flowFile, destination);
+ }
+
+ /**
+ * Returns a ProvenanceReporter that is tied to this ProcessSession.
+ *
+ * @return the provenance reporter
+ */
+ @Override
+ public ProvenanceReporter getProvenanceReporter() {
+ return s.getProvenanceReporter();
+ }
+
+ @Override
+ public void migrate(ProcessSession newOwner, Collection<FlowFile> flowFiles) {
+ flowFiles = unwrap(flowFiles);
+ s.migrate(newOwner, flowFiles);
+ }
+
+ /**
+ * Provides an OutputStream that can be used to write to the contents of the
+ * given FlowFile.
+ *
+ * @param source to write to
+ *
+ * @return an OutputStream that can be used to write to the contents of the FlowFile
+ *
+ * @throws IllegalStateException if detected that this method is being
+ * called from within a callback of another method in this session and for
+ * the given FlowFile(s), or if there is an open InputStream or OutputStream for the FlowFile's content
+ * (see {@link #read(FlowFile)}).
+ * @throws FlowFileHandlingException if the given FlowFile is already
+ * transferred or removed or doesn't belong to this session. Automatic
+ * rollback will occur.
+ * @throws MissingFlowFileException if the given FlowFile content cannot be
+ * found. The FlowFile should no longer be referenced, will be internally
+ * destroyed, and the session is automatically rolled back and what is left
+ * of the FlowFile is destroyed.
+ * @throws FlowFileAccessException if some IO problem occurs accessing
+ * FlowFile content; if an attempt is made to access the OutputStream
+ * provided to the given OutputStreamCallaback after this method completed
+ * its execution
+ */
+ @Override
+ public OutputStream write(FlowFile source) {
+ source = unwrap(source);
+ return s.write(source);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/nifi/blob/c7a5a09b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/flow/SessionFile.java
----------------------------------------------------------------------
diff --git a/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/flow/SessionFile.java b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/flow/SessionFile.java
new file mode 100644
index 0000000..6b99c8f
--- /dev/null
+++ b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/flow/SessionFile.java
@@ -0,0 +1,243 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.nifi.processors.groovyx.flow;
+
+import java.io.InputStream;
+import java.util.Map;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Collection;
+
+import org.apache.nifi.flowfile.FlowFile;
+import org.apache.nifi.processor.Relationship;
+import org.apache.nifi.processor.io.OutputStreamCallback;
+import org.apache.nifi.processor.io.StreamCallback;
+import org.apache.nifi.processor.io.InputStreamCallback;
+
+/**
+ * The Flow file implementation that contains reference to the session.
+ * So all commands become easier. Example:
+ * <code>flowFile.putAttribute("AttrName", "AttrValue");</code>
+ */
+@SuppressWarnings("unused")
+public abstract class SessionFile implements FlowFile {
+
+ FlowFile flowFile;
+ ProcessSessionWrap session;
+
+ protected SessionFile(ProcessSessionWrap session, FlowFile f) {
+ if (f == null || session == null) {
+ throw new NullPointerException("Session and FlowFile are mandatory session=" + session + " file=" + f);
+ }
+ if (f instanceof SessionFile) {
+ throw new RuntimeException("file could be instanceof SessionFile");
+ }
+ this.flowFile = f;
+ this.session = session;
+ }
+
+ /**
+ * Returns original session.
+ */
+ public ProcessSessionWrap session() {
+ return session;
+ }
+
+ /**
+ * Clone flowfile with or without content.
+ *
+ * @param cloneContent clone content or not. attributes cloned in any case.
+ * @return new flow file
+ */
+ public SessionFile clone(boolean cloneContent) {
+ if (cloneContent) {
+ return session.clone(flowFile); //new SessionFile(session, session.clone(flowFile));
+ }
+ return session.create(flowFile); //session.wrap( session.create(flowFile) );
+ }
+
+ /**
+ * Returns content of the flow file as InputStream.
+ */
+ public InputStream read() {
+ return session.read(flowFile);
+ }
+
+ /**
+ * read flowfile content.
+ */
+ public void read(InputStreamCallback c) {
+ session.read(flowFile, c);
+ }
+
+ /**
+ * write flowfile content.
+ *
+ * @return reference to self
+ */
+ public SessionFile write(StreamCallback c) {
+ session.write(this, c);
+ return this;
+ }
+
+ /**
+ * write flowfile content.
+ *
+ * @return reference to self
+ */
+ public SessionFile write(OutputStreamCallback c) {
+ session.write(this, c);
+ return this;
+ }
+
+ /**
+ * append flowfile content.
+ *
+ * @return reference to self
+ */
+ public SessionFile append(OutputStreamCallback c) {
+ session.append(this, c);
+ return this;
+ }
+
+ /**
+ * set attribute value.
+ *
+ * @return reference to self
+ */
+ public SessionFile putAttribute(String key, String value) {
+ session.putAttribute(this, key, value);
+ return this;
+ }
+
+ /**
+ * Copy attributes from map into flowfile.
+ *
+ * @return reference to self
+ */
+ public SessionFile putAllAttributes(Map<String,String> m) {
+ session.putAllAttributes(this, m);
+ return this;
+ }
+
+ /**
+ * Removes one attribute.
+ *
+ * @return reference to self
+ */
+ public SessionFile removeAttribute(String key) {
+ session.removeAttribute(this, key);
+ return this;
+ }
+
+ /**
+ * Removes attributes by list.
+ *
+ * @return reference to self
+ */
+ public SessionFile removeAllAttributes(Collection<String> keys) {
+ Set<String> keySet = (Set<String>) (keys instanceof Set ? keys : new HashSet<>(keys));
+ session.removeAllAttributes(this, keySet);
+ return this;
+ }
+
+ /**
+ * Transfers to defined relationship or to input relationship if parameter is null.
+ */
+ public void transfer(Relationship r) {
+ if (r == null) {
+ session.transfer(this);
+ } else {
+ session.transfer(this, r);
+ }
+ }
+
+ /**
+ * Drops this flow file from session.
+ */
+ public void remove() {
+ session.remove(this);
+ }
+
+ //OVERRIDE
+ @Override
+ public long getId() {
+ return flowFile.getId();
+ }
+
+ @Override
+ public long getEntryDate() {
+ return flowFile.getEntryDate();
+ }
+
+ @Override
+ public long getLineageStartDate() {
+ return flowFile.getLineageStartDate();
+ }
+
+ @Override
+ public long getLineageStartIndex() {
+ return flowFile.getLineageStartIndex();
+ }
+
+ @Override
+ public Long getLastQueueDate() {
+ return flowFile.getLastQueueDate();
+ }
+
+ @Override
+ public long getQueueDateIndex() {
+ return flowFile.getQueueDateIndex();
+ }
+
+ @Override
+ public boolean isPenalized() {
+ return flowFile.isPenalized();
+ }
+
+ @Override
+ public String getAttribute(String key) {
+ return flowFile.getAttribute(key);
+ }
+
+ @Override
+ public long getSize() {
+ return flowFile.getSize();
+ }
+
+ /**
+ * @return an unmodifiable map of the flow file attributes
+ */
+ @Override
+ public Map<String, String> getAttributes() {
+ return flowFile.getAttributes();
+ }
+
+ @SuppressWarnings("NullableProblems")
+ public int compareTo(FlowFile other) {
+ if (other instanceof SessionFile) {
+ other = ((SessionFile) other).flowFile;
+ }
+ return flowFile.compareTo(other);
+ }
+
+ @Override
+ public String toString() {
+ return "WRAP[" + flowFile.toString() + "]";
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/nifi/blob/c7a5a09b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/sql/OSql.java
----------------------------------------------------------------------
diff --git a/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/sql/OSql.java b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/sql/OSql.java
new file mode 100644
index 0000000..550dbb6
--- /dev/null
+++ b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/sql/OSql.java
@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.nifi.processors.groovyx.sql;
+
+import groovy.sql.Sql;
+import groovy.sql.InParameter;
+import groovy.lang.GString;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.Types;
+import java.sql.SQLException;
+import java.io.InputStream;
+import java.io.Reader;
+
+/***
+ * class to simplify work with CLOB, BLOB, DATE, and TIMESTAMP types.
+ * Allows following parameters set correctly Sql.BLOB(InputStream), Sql.CLOB(Reader), DATE(java.util.Date), TIMESTAMP(java.util.Date)
+ */
+
+public class OSql extends Sql {
+ public OSql(Connection connection) {
+ super(connection);
+ }
+
+ protected void setObject(PreparedStatement statement, int i, Object value) throws SQLException {
+ try {
+ if (value instanceof InParameter) {
+ InParameter p = (InParameter) value;
+ if (p.getType() == Types.BLOB && p.getValue() instanceof InputStream) {
+ statement.setBlob(i, (InputStream) p.getValue());
+ return;
+ }
+ if (p.getType() == Types.CLOB && p.getValue() instanceof Reader) {
+ statement.setClob(i, (Reader) p.getValue());
+ return;
+ }
+ if (p.getType() == Types.DATE && p.getValue() instanceof java.util.Date && !(p.getValue() instanceof java.sql.Date)) {
+ statement.setDate(i, new java.sql.Date(((java.util.Date) p.getValue()).getTime()));
+ return;
+ }
+ if (p.getType() == Types.TIMESTAMP && p.getValue() instanceof java.util.Date && !(p.getValue() instanceof java.sql.Timestamp)) {
+ statement.setTimestamp(i, new java.sql.Timestamp(((java.util.Date) p.getValue()).getTime()));
+ return;
+ }
+ }
+ if (value instanceof GString) {
+ value = value.toString();
+ }
+ super.setObject(statement, i, value);
+ } catch (Exception e) {
+ throw new SQLException("Can't set a parameter #" + i + " to value type " + (value == null ? "null" : value.getClass().getName()) + ": " + e.getMessage(), e);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/nifi/blob/c7a5a09b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Files.java
----------------------------------------------------------------------
diff --git a/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Files.java b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Files.java
new file mode 100644
index 0000000..ffee3b0
--- /dev/null
+++ b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Files.java
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.nifi.processors.groovyx.util;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/**
+ * Helpers to work with files
+ */
+public class Files {
+
+ /**
+ * Classpath list separated by semicolon. You can use masks like `*`, `*.jar` in file name.
+ *
+ * @return file list defined by classpath parameter
+ */
+ public static Set<File> listPathsFiles(String classpath) {
+ if (classpath == null || classpath.length() == 0) {
+ return Collections.emptySet();
+ }
+ Set<File> files = new HashSet<>();
+ for (String cp : classpath.split("\\s*;\\s*")) {
+ files.addAll(listPathFiles(cp));
+ }
+ return files;
+ }
+
+ /**
+ * returns file list from one path. the path could be exact filename (one file returned), exact directory (all files from dir returned)
+ * or exact dir with masked file names like ./dir/*.jar (all jars returned)
+ */
+ public static List<File> listPathFiles(String path) {
+ File f = new File(path);
+ String fname = f.getName();
+ if (fname.contains("?") || fname.contains("*")) {
+ Pattern pattern = Pattern.compile(fname.replace(".", "\\.").replace("?", ".?").replace("*", ".*?"));
+ File[] list = f.getParentFile().listFiles((dir, name) -> pattern.matcher(name).find());
+ return list==null ? Collections.emptyList() : Arrays.asList(list);
+ }
+ if (!f.exists()) {
+ System.err.println("WARN: path not found for: " + f);
+ }
+ return Arrays.asList(f);
+ }
+}
http://git-wip-us.apache.org/repos/asf/nifi/blob/c7a5a09b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Throwables.java
----------------------------------------------------------------------
diff --git a/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Throwables.java b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Throwables.java
new file mode 100644
index 0000000..455b080
--- /dev/null
+++ b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Throwables.java
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.nifi.processors.groovyx.util;
+
+import java.lang.reflect.InvocationTargetException;
+import java.io.StringWriter;
+import java.io.PrintWriter;
+
+/**
+ * Class with helper to return simplified human readable error message with one main `at` code position.
+ */
+public class Throwables {
+ /** returns stacktrace as a String */
+ public static String stringStackTrace(Throwable e) {
+ StringWriter sw = new StringWriter(500);
+ PrintWriter pw = new PrintWriter(sw);
+ e.printStackTrace(pw);
+ pw.flush();
+ sw.flush();
+ return sw.toString();
+ }
+
+ /**
+ * returns error message with one main line from stacktrace
+ */
+ public static String getMessage(Throwable e) {
+ return getMessage(e, null, -1);
+ }
+
+ /**
+ * returns human readable error message with only one element from stacktrace.
+ * The parameter `priority` could identify the stacktrace element.
+ * To find stacktrace element tries to find `priority`,
+ * then any non-standard java/groovy class.
+ * @param e throwable to convert to message
+ * @param priority package name, class, or object that could identify the stacktrace element
+ * @param maxlen the max length of returned string or -1 for unlimited
+ */
+ public static String getMessage(Throwable e, Object priority, int maxlen) {
+
+ if (e == null) {
+ return null;
+ }
+ e = getRootException(e);
+
+ StackTraceElement[] trace = e.getStackTrace();
+ int traceIndex = -1;
+
+ if (priority != null) {
+ if (priority instanceof String) {
+ for (int i = 0; i < trace.length; i++) {
+ if (trace[i].getClassName().startsWith((String) priority)) {
+ traceIndex = i;
+ break;
+ }
+ }
+ } else {
+ if (!(priority instanceof Class)) {
+ priority = priority.getClass();
+ }
+
+ String cl = ((Class) priority).getName();
+ for (int i = 0; i < trace.length; i++) {
+ if (trace[i].getClassName().startsWith(cl)) {
+ traceIndex = i;
+ break;
+ }
+ }
+ if (traceIndex == -1) {
+ cl = ((Class) priority).getPackage().getName();
+ for (int i = 0; i < trace.length; i++) {
+ if (trace[i].getClassName().startsWith(cl)) {
+ traceIndex = i;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ if (traceIndex == -1) {
+ for (int i = 0; i < trace.length; i++) {
+ String cl = trace[i].getClassName();
+ if (cl.startsWith("java.") || cl.startsWith("javax.") || cl.startsWith("org.omg.") || cl.startsWith("org.w3c.") || cl.startsWith("org.xml.") || cl.startsWith("groovy.lang.") || cl
+ .startsWith("groovy.util.") || cl.startsWith("org.codehaus.") || cl.startsWith("com.springsource.") || cl.startsWith("org.springframework.") || cl.startsWith("org.apache.")
+ || cl.startsWith("sun.") || cl.startsWith("com.sun.") || cl.startsWith("org.junit.") || cl.startsWith("junit.framework.")
+
+ ) {
+ //skip standard classes
+ } else {
+ traceIndex = i;
+ break;
+ }
+ }
+ }
+
+ if (traceIndex == -1) {
+ traceIndex = 0;
+ }
+
+ //build message text
+ String msg = e.getMessage();
+ if (msg == null) {
+ msg = "";
+ }
+ msg = msg.trim();
+ //append dot at the end if no others
+ if (msg.length() > 0 && ".!:,;?".indexOf(msg.substring(msg.length() - 1)) == -1) {
+ msg += ".";
+ }
+
+ //exception class name without package
+ String msgSuffix = " " + e.getClass().getName().replaceAll("^.*\\.(\\w+)$", "$1") + " at ";
+ //append callers line
+ if (traceIndex < 0 || traceIndex >= trace.length) {
+ System.err.println("Error formatting exception: " + e);
+ e.printStackTrace(System.err);
+ msgSuffix = e.getClass().getName();
+ } else {
+ msgSuffix += trace[traceIndex].toString();
+ }
+ if (maxlen > 0 && msgSuffix.length() + msg.length() > maxlen) {
+ if (maxlen > msgSuffix.length() + 2) {
+ int newlen = maxlen - msgSuffix.length() - 2;
+ if (newlen < msg.length()) {
+ msg = msg.substring(0, newlen);
+ }
+ msg = msg + ".." + msgSuffix;
+ } else if (msg.length() > maxlen) {
+ msg = msg.substring(0, maxlen);
+ }
+ } else {
+ msg = msg + msgSuffix;
+ }
+
+ return msg;
+ }
+
+ private static Throwable getRootException(Throwable e) {
+ Throwable t;
+
+ if (e instanceof InvocationTargetException) {
+ t = ((InvocationTargetException) e).getTargetException();
+ } else if (e instanceof RuntimeException) {
+ t = e.getCause();
+ } else if (e.getCause() != null && e.getClass().getName().equals(e.getCause().getClass().getName())) {
+ t = e.getCause();
+ /*
+ }else if(e instanceof UserError){
+ return e;
+ */
+ } else {
+ return e;
+ }
+
+ if (t != null) {
+ return getRootException(t);
+ }
+ return e;
+ }
+}
+
http://git-wip-us.apache.org/repos/asf/nifi/blob/c7a5a09b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Validators.java
----------------------------------------------------------------------
diff --git a/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Validators.java b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Validators.java
new file mode 100644
index 0000000..3893851
--- /dev/null
+++ b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/java/org/apache/nifi/processors/groovyx/util/Validators.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.nifi.processors.groovyx.util;
+
+import java.io.File;
+
+import org.apache.nifi.components.ValidationResult;
+import org.apache.nifi.components.Validator;
+
+/***
+ * class with validators
+ */
+
+public class Validators {
+ /**
+ * differs from standard file exists validator by supporting expression language values. TODO: maybe there is a bug in standard validator?
+ */
+ public static Validator createFileExistsAndReadableValidator() {
+ return (subject, input, context) -> {
+ final String substituted;
+ try {
+ substituted = context.newPropertyValue(input).evaluateAttributeExpressions().getValue();
+ } catch (final Exception e) {
+ return new ValidationResult.Builder()
+ .subject(subject)
+ .input(input)
+ .valid(false)
+ .explanation("Not a valid Expression Language value: " + e.getMessage())
+ .build();
+ }
+
+ final File file = new File(substituted);
+ final boolean valid = file.exists() && file.canRead();
+ final String explanation = valid ? null : "File " + file + " does not exist or cannot be read";
+ return new ValidationResult.Builder()
+ .subject(subject)
+ .input(input)
+ .valid(valid)
+ .explanation(explanation)
+ .build();
+ };
+ }
+}
http://git-wip-us.apache.org/repos/asf/nifi/blob/c7a5a09b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/META-INF/services/org.apache.nifi.processor.Processor
----------------------------------------------------------------------
diff --git a/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/META-INF/services/org.apache.nifi.processor.Processor b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/META-INF/services/org.apache.nifi.processor.Processor
new file mode 100644
index 0000000..42959a2
--- /dev/null
+++ b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/META-INF/services/org.apache.nifi.processor.Processor
@@ -0,0 +1,15 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+org.apache.nifi.processors.groovyx.ExecuteGroovyScript
http://git-wip-us.apache.org/repos/asf/nifi/blob/c7a5a09b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/SQL.gif
----------------------------------------------------------------------
diff --git a/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/SQL.gif b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/SQL.gif
new file mode 100644
index 0000000..49e5388
Binary files /dev/null and b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/SQL.gif differ
http://git-wip-us.apache.org/repos/asf/nifi/blob/c7a5a09b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/SQL2.gif
----------------------------------------------------------------------
diff --git a/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/SQL2.gif b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/SQL2.gif
new file mode 100644
index 0000000..602c260
Binary files /dev/null and b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/SQL2.gif differ
http://git-wip-us.apache.org/repos/asf/nifi/blob/c7a5a09b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/additionalDetails.html
----------------------------------------------------------------------
diff --git a/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/additionalDetails.html b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/additionalDetails.html
new file mode 100644
index 0000000..3adbb36
--- /dev/null
+++ b/nifi-nar-bundles/nifi-groovyx-bundle/nifi-groovyx-processors/src/main/resources/docs/org.apache.nifi.processors.groovyx.ExecuteGroovyScript/additionalDetails.html
@@ -0,0 +1,203 @@
+<!DOCTYPE html>
+<html lang="en">
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<head>
+ <meta charset="utf-8" />
+ <title>Groovy</title>
+ <!--link rel="stylesheet" href="../../css/component-usage.css" type="text/css" /-->
+ <link rel="stylesheet" href="/nifi-docs/css/component-usage.css" type="text/css" />
+</head>
+
+<body>
+<h2>Summary</h2>
+<p>This is a grooviest groovy script :)</p>
+<h2>Script Bindings:</h2>
+<table>
+<tr><th>variable</th><th>type</th><th>description</th></tr>
+<tr>
+ <td>session</td>
+ <td>org.apache.nifi.processor.ProcessSession</td>
+ <td>the session that is used to get, change, and transfer input files</td>
+</tr>
+<tr>
+ <td>context</td>
+ <td>org.apache.nifi.processor.ProcessContext</td>
+ <td>the context (almost unuseful)</td>
+</tr>
+<tr>
+ <td>log</td>
+ <td>org.apache.nifi.logging.ComponentLog</td>
+ <td>the logger for this processor instance</td>
+</tr>
+<tr>
+ <td>REL_SUCCESS</td>
+ <td>org.apache.nifi.processor.Relationship</td>
+ <td>the success relationship</td>
+</tr>
+<tr>
+ <td>REL_FAILURE</td>
+ <td>org.apache.nifi.processor.Relationship</td>
+ <td>the failure relationship</td>
+</tr>
+<tr>
+ <td>CTL</td>
+ <td>java.util.HashMap<String,<a href="https://github.com/apache/nifi/blob/master/nifi-api/src/main/java/org/apache/nifi/controller/ControllerService.java">ControllerService</a>></td>
+ <td>Map populated with controller services defined with `CTL.*` processor properties.
+ <br/>The `CTL.` prefixed properties could be linked to controller service and provides access to this service from a script without additional code.</td>
+</tr>
+<tr>
+ <td>SQL</td>
+ <td>java.util.HashMap<String, <a href="http://docs.groovy-lang.org/latest/html/api/groovy/sql/Sql.html">groovy.sql.Sql</a>></td>
+ <td>Map populated with `groovy.sql.Sql` objects connected to corresponding database defined with `SQL.*` processor properties.
+ <br/>The `SQL.` prefixed properties could be linked only to DBCPSercice.</td>
+</tr>
+<tr>
+ <td>Dynamic processor properties</td>
+ <td>org.apache.nifi.components.PropertyDescriptor</td>
+ <td>All processor properties not started with `CTL.` or `SQL.` are bound to script variables</td>
+</tr>
+</table>
+
+<h2>SQL map details</h2>
+<p>
+<b>Example:</b> if you defined property <code>`SQL.mydb`</code> and linked it to any DBCPService,
+then you can access it from code <code>SQL.mydb.rows('select * from mytable')</code><br/>
+
+<br/>The processor automatically takes connection from dbcp service before executing script and tries to handle transaction:
+<br/> database transactions automatically rolled back on script exception and committed on success.
+<br/>Or you can manage transaction manually.
+<br/>NOTE: Script must not disconnect connection.
+
+<br/><img src="SQL.gif"/>
+<br/><img src="SQL2.gif"/>
+</p>
+
+<h2>SessionFile - flow file extension</h2>
+<p>
+ The (org.apache.nifi.processors.groovyx.flow.SessionFile) is an actual object returned by session in Extended Groovy processor.<br/>
+ This flow file is a container that references session and the real flow file.<br/>
+ This allows to use simplified syntax to work with file attributes and content:
+</p>
+<p><i>set new attribute value</i></p>
+<pre>
+ flowFile.ATTRIBUTE_NAME = ATTRIBUTE_VALUE
+ flowFile.'mime.type' = 'text/xml'
+ flowFile.putAttribute("ATTRIBUTE_NAME", ATTRIBUTE_VALUE)
+ //the same as
+ flowFile = session.putAttribute(flowFile, "ATTRIBUTE_NAME", ATTRIBUTE_VALUE)
+</pre>
+
+<p><i>remove attribute</i></p>
+<pre>
+ flowFile.ATTRIBUTE_NAME = null
+ //equals to
+ flowFile = session.removeAttribute(flowFile, "ATTRIBUTE_NAME")
+</pre>
+
+<p><i>get attribute value</i></p>
+<pre>
+ String a = flowFile.ATTRIBUTE_NAME
+</pre>
+
+<p><i>write content</i></p>
+<pre>
+ flowFile.write("UTF-8", "THE CharSequence to write into flow file replacing current content")
+ flowFile.write("UTF-8"){writer->
+ do something with java.io.Writer...
+ }
+ flowFile.write{outStream->
+ do something with output stream...
+ }
+ flowFile.write{inStream, outStream->
+ do something with input and output streams...
+ }
+</pre>
+
+<p><i>get content</i></p>
+<pre>
+ InputStream i = flowFile.read()
+ def json = new groovy.json.JsonSlurper().parse( flowFile.read() )
+ String text = flowFile.read().getText("UTF-8")
+</pre>
+
+<p><i>transfer flow file to success relation</i></p>
+<pre>
+ REL_SUCCESS << flowFile
+ flowFile.transfer(REL_SUCCESS)
+ //the same as:
+ session.transfer(flowFile, REL_SUCCESS)
+</pre>
+
+<p><i>work with dbcp</i></p>
+<pre>
+ import groovy.sql.Sql
+
+ //define property named `SQL.db` connected to a DBCPConnectionPool controller service
+ //for this case it's an H2 database example
+
+ //read value from the database with prepared statement
+ //and assign into flowfile attribute `db.yesterday`
+ def daysAdd = -1
+ def row = SQL.db.firstRow("select dateadd('DAY', ${daysAdd}, sysdate) as DB_DATE from dual")
+ flowFile.'db.yesterday' = row.DB_DATE
+
+ //to work with BLOBs and CLOBs in the database
+ //use parameter casting using groovy.sql.Sql.BLOB(Stream) and groovy.sql.Sql.CLOB(Reader)
+
+ //write content of the flow file into database blob
+ flowFile.read{ rawIn->
+ def parms = [
+ p_id : flowFile.ID as Long, //get flow file attribute named `ID`
+ p_data : Sql.BLOB( rawIn ), //use input stream as BLOB sql parameter
+ ]
+ SQL.db.executeUpdate(parms, "update mytable set data = :p_data where id = :p_id")
+ }
+</pre>
+
+
+<h2>Handling processor start & stop</h2>
+
+<p>In the extended groovy processor you can catch `start` and `stop` events by providing corresponding static methods:</p>
+<pre>
+ import org.apache.nifi.processor.ProcessContext
+ import java.util.concurrent.atomic.AtomicLong
+
+ class Const{
+ static Date startTime = null;
+ static AtomicLong triggerCount = null;
+ }
+
+ static onStart(ProcessContext context){
+ Const.startTime = new Date()
+ Const.triggerCount = new AtomicLong(0)
+ println "onStart $context ${Const.startTime}"
+ }
+
+ static onStop(ProcessContext context){
+ def alive = (System.currentTimeMillis() - Const.startTime.getTime()) / 1000
+ println "onStop $context executed ${ Const.triggerCount } times during ${ alive } seconds"
+ }
+
+
+ flowFile.'trigger.count' = Const.triggerCount.incrementAndGet()
+ REL_SUCCESS << flowFile
+</pre>
+<br/>
+<br/>
+<br/>
+<br/>
+</body>
+</html>
\ No newline at end of file