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&lt;String,<a href="https://github.com/apache/nifi/blob/master/nifi-api/src/main/java/org/apache/nifi/controller/ControllerService.java">ControllerService</a>&gt;</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&lt;String, <a href="http://docs.groovy-lang.org/latest/html/api/groovy/sql/Sql.html">groovy.sql.Sql</a>&gt;</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 &amp; 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