Nifi之ExecuteScript使用方法 (二)
本文是一系列文章中的第二篇，描述了如何使用ExecuteScript完成某些任务的各种"方法".
本文介绍了如何使用NiFi处理器ExecuteScript完成某些任务的各种"recipes"，以及 Groovy，Jython，Javascript（Nashorn）和JRuby中给出的示例。这是本系列的第2部分，我将讨论读取和写入流文件内容以及错误处理。
第1部分- NiFi API和FlowFiles简介
- 从传入队列获取流文件
- 创建新的流文件
- 使用流文件属性
- 传输流文件
- 记录
第2部分 - FlowFile I / O和错误处理
- 从流文件中读取
- 写入流文件
- 读取和写入流文件
- 错误处理
第3部分- 高级功能
- 使用动态属性
- 添加模块
- 国家管理
- 访问控制器服务
FlowFile I / O简介
NiFi中的流文件由两个主要组件构成，即属性和内容。属性是关于内容/流文件的元数据，我们在本系列的第一部分看到了如何使用ExecuteScript来操作它们.
流文件的内容本质上只是一个字节集合，没有固有的结构，模式，格式等。各种NiFi处理器假设传入的流文件具有特定的模式/格式(或者从属性中确定它作为“mime.type”或以其他方式推断它)。然后，这些处理器可以基于文件确实具有该格式的假设来对内容起作用（并且如果它们不这样，则经常转移到“Failure”关系队列）。处理器也可以输出指定格式的流文件，这在处理器中有描述。NiFi文档。
流文件内容的输入和输出(I/O)通过ProcessSession API提供（有关更多信息，请参阅第1部分）同时对外开放了"session 变量"以供调用。我们可以通过调用session.read()获得FlowFile的输入流对象或调用session.write()获得FlowFile的输出流对象.这两个方法会调用相应的回调接口和回调函数，并返回InputStream和/或OutputStream引用以供回调使用。有三个主要的回调接口，每个接口都有自己的用例：
InputStreamCallback
session.read(flowFile，inputStreamCallback)方法会调用输入流回调接口,该方法会返回一个从FlowFile中读取到数据的输入流.这个回调函数只有一个方法
void process(InputStream in) throws IOException这个接口提供了一个managed输入流供调用者使用,这个流会自动的打开和关闭,也支持手动关闭.如果您只是从特定的流文件中读取数据，而不是将数据写回该文件，那么您将使用这种办法.
比如我们想做的事情是接收到一条流数据,将其切分成多条输出出去.这是一个很常用也很简单的场景,此时我们就可以使用上面的办法.
OutputStreamCallback
输出流回调接口在调用session.write(FlowFile,outputStreamCallback)的时候被调用,它会返回一个向FlowFile中写数据的OutputSteam.这个接口也只有一个方法
void process(OutputStream out) throws IOException此接口提供输出流以供使用。尽管可以手动关闭流，但输出流会自动打开和关闭 - 如果包含这些流的任何流打开应该清除的资源，这一点就变得非常重要了。
使用方法 : 比如ExecuteScript将从内部或外部文件生成数据，但不生成流文件。然后你将使用session.create()创建一个新的FlowFile,再使用session.write(flowFile，outputStreamCallback)来插入内容。
StreamCallback
当调用session.write(FlowFile,StreamCallback)的时候,会返回InputStream和OutputStream,从中读写流文件的内容.接口方法如下:
void process （InputStream in ，OutputStream out ）抛出IOException 同上边的接口相同,改接口也会自动关闭流也支持手动关闭.
使用场景 : 当您想要处理传入的流文件并用新的东西覆盖其内容时，例如 EncryptContent处理器。
由于这些回调是Java对象，因此脚本必须创建并将其传递给会话方法，这些recipes将针对各种脚本语言进行说明。其他读取和写入流文件的方法：
- 使用session.read（flowFile）返回一个InputStream。这减轻了对InputStreamCallback的需求，而是返回可以读取的InputStream。作为交换，您必须手动管理（关闭，例如）InputStream。
- 使用session.importFrom（inputStream，flowFile）从InputStream写入FlowFile。这取代了传递了OutputStreamCallback的session.write（）的需要。
代码样例
应用场景1 :使用回调读取传入流文件的内容,您有连接到ExecuteScript的传入连接，并希望从队列中检索流文件的内容以进行处理。
方案:使用来自session对象的方法read(flowFile，inputStreamCallback)。read()方法需要传入一个InputStreamCallback对象。请注意，因为InputStreamCallback是一个对象，所以默认情况下内容只对该对象可见。如果需要使用read()方法之外的数据，请使用全局范围的变量。这些示例将传入流文件的完整内容存储到String中（使用Apache Commons的IOUtils类）。注意：对于大流量文件，这不是最好的技术; 相反，您应该只读取您需要的数据，并根据需要进行处理。对于像SplitText这样的东西，你可以一次读取一行并在InputStreamCallback中处理它，或者使用前面提到的session.read(flowFile)方法来获得在回调之外使用的InputStream引用。
Groovy
import org.apache.commons.io.IOUtils
import java.nio.charset.StandardCharsets
flowFile = session.get()
if(!flowFile)return
def text = ''
// Cast a closure with an inputStream parameter to InputStreamCallback
session.read(flowFile, {inputStream ->
text = IOUtils.toString(inputStream, StandardCharsets.UTF_8)
// Do something with text here
} as InputStreamCallback)Jython
from org.apache.commons.io import IOUtils
from java.nio.charset import StandardCharsets
from org.apache.nifi.processor.io import InputStreamCallback
# Define a subclass of InputStreamCallback for use in session.read()
class PyInputStreamCallback(InputStreamCallback):
def __init__(self):
pass
def process(self, inputStream):
text = IOUtils.toString(inputStream, StandardCharsets.UTF_8)
# Do something with text here
# end class
flowFile = session.get()
if(flowFile != None):
session.read(flowFile, PyInputStreamCallback())
# implicit return at the end
JavaScript
var InputStreamCallback = Java.type("org.apache.nifi.processor.io.InputStreamCallback")
var IOUtils = Java.type("org.apache.commons.io.IOUtils")
var StandardCharsets = Java.type("java.nio.charset.StandardCharsets")
var flowFile = session.get();
if(flowFile != null) {
// Create a new InputStreamCallback, passing in a function to define the interface method
session.read(flowFile,
new InputStreamCallback(function(inputStream) {
var text = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
// Do something with text here
}));
}JRuby
java_import org.apache.commons.io.IOUtils
java_import org.apache.nifi.processor.io.InputStreamCallback
# Define a subclass of InputStreamCallback for use in session.read()
class JRubyInputStreamCallback
include InputStreamCallback
def process(inputStream)
text = IOUtils.toString(inputStream)
# Do something with text here
end
end
jrubyInputStreamCallback = JRubyInputStreamCallback.new
flowFile = session.get()
if flowFile != nil
session.read(flowFile, jrubyInputStreamCallback)
end
应用场景2 : 使用回调函数将内容写入传出流文件,我们希望对传入的流文件除了读取内容,还要填充新的内容.
方案 : 使用会话对象中的write(flowFile，outputStreamCallback)方法。传递给write()方法需要一个OutputStreamCallback对象。请注意，因为OutputStreamCallback是一个对象，所以默认情况下内容只对该对象可见。如果需要使用write()方法之外的数据，请使用更全局范围的变量。这些示例将示例String写入flowFile。
Groovy
import org.apache.commons.io.IOUtils
import java.nio.charset.StandardCharsets
flowFile = session.get()
if(!flowFile) return
def text = 'Hello world!'
// Cast a closure with an outputStream parameter to OutputStreamCallback
flowFile = session.write(flowFile, {outputStream ->
outputStream.write(text.getBytes(StandardCharsets.UTF_8))
} as OutputStreamCallback)Jython
from org.apache.commons.io import IOUtils
from java.nio.charset import StandardCharsets
from org.apache.nifi.processor.io import OutputStreamCallback
# Define a subclass of OutputStreamCallback for use in session.write()
class PyOutputStreamCallback(OutputStreamCallback):
def __init__(self):
pass
def process(self, outputStream):
outputStream.write(bytearray('Hello World!'.encode('utf-8')))
# end class
flowFile = session.get()
if(flowFile != None):
flowFile = session.write(flowFile, PyOutputStreamCallback())
# implicit return at the endJavaScript
var OutputStreamCallback = Java.type("org.apache.nifi.processor.io.OutputStreamCallback");
var IOUtils = Java.type("org.apache.commons.io.IOUtils");
var StandardCharsets = Java.type("java.nio.charset.StandardCharsets");
var flowFile = session.get();
if(flowFile != null) {
// Create a new OutputStreamCallback, passing in a function to define the interface method
flowFile = session.write(flowFile,
new OutputStreamCallback(function(outputStream) {
outputStream.write("Hello World!".getBytes(StandardCharsets.UTF_8))
}));
}
JRuby
java_import org.apache.commons.io.IOUtils
java_import java.nio.charset.StandardCharsets
java_import org.apache.nifi.processor.io.OutputStreamCallback
# Define a subclass of OutputStreamCallback for use in session.write()
class JRubyOutputStreamCallback
include OutputStreamCallback
def process(outputStream)
outputStream.write("Hello World!".to_java.getBytes(StandardCharsets::UTF_8))
end
end
jrubyOutputStreamCallback = JRubyOutputStreamCallback.new
flowFile = session.get()
if flowFile != nil
flowFile = session.write(flowFile, jrubyOutputStreamCallback)
end
应用场景3 : 使用回调覆盖带有更新内容的传入流文件,您希望重用传入的流文件，但希望修改其传出流文件的内容。
方案 : 使用来自session对象的write(flowFile，streamCallback)方法。传递给write()方法需要StreamCallback对象。StreamCallback提供InputStream（来自传入流文件）和outputStream（用于该流文件的下一个版本），因此您可以使用InputStream获取流文件的当前内容，然后修改它们并将它们写回到流文件。这会覆盖流文件的内容，因此对于追加，您必须通过附加读入内容来处理它，或者使用不同的方法（使用session.append()而不是session.write()）。请注意，由于StreamCallback是一个对象，因此默认情况下内容仅对该对象可见。如果需要使用write()方法之外的数据，请使用更全局范围的变量。
Groovy
import org.apache.commons.io.IOUtils
import java.nio.charset.StandardCharsets
flowFile = session.get()
if(!flowFile) return
def text = 'Hello world!'
// Cast a closure with an inputStream and outputStream parameter to StreamCallback
flowFile = session.write(flowFile, {inputStream, outputStream ->
text = IOUtils.toString(inputStream, StandardCharsets.UTF_8)
outputStream.write(text.reverse().getBytes(StandardCharsets.UTF_8))
} as StreamCallback)
session.transfer(flowFile, REL_SUCCESS)Jython
from org.apache.commons.io import IOUtils
from java.nio.charset import StandardCharsets
from org.apache.nifi.processor.io import StreamCallback
# Define a subclass of StreamCallback for use in session.write()
class PyStreamCallback(StreamCallback):
def __init__(self):
pass
def process(self, inputStream, outputStream):
text = IOUtils.toString(inputStream, StandardCharsets.UTF_8)
outputStream.write(bytearray('Hello World!'[::-1].encode('utf-8')))
# end class
flowFile = session.get()
if(flowFile != None):
flowFile = session.write(flowFile, PyStreamCallback())
# implicit return at the endJavaScript
var StreamCallback = Java.type("org.apache.nifi.processor.io.StreamCallback");
var IOUtils = Java.type("org.apache.commons.io.IOUtils");
var StandardCharsets = Java.type("java.nio.charset.StandardCharsets");
var flowFile = session.get();
if(flowFile != null) {
// Create a new StreamCallback, passing in a function to define the interface method
flowFile = session.write(flowFile,
new StreamCallback(function(inputStream, outputStream) {
var text = IOUtils.toString(inputStream, StandardCharsets.UTF_8)
outputStream.write(text.split("").reverse().join("").getBytes(StandardCharsets.UTF_8))
}));
}JRuby
java_import org.apache.commons.io.IOUtils
java_import java.nio.charset.StandardCharsets
java_import org.apache.nifi.processor.io.StreamCallback
# Define a subclass of StreamCallback for use in session.write()
class JRubyStreamCallback
include StreamCallback
def process(inputStream, outputStream)
text = IOUtils.toString(inputStream)
outputStream.write((text.reverse!).to_java.getBytes(StandardCharsets::UTF_8))
end
end
jrubyStreamCallback = JRubyStreamCallback.new
flowFile = session.get()
if flowFile != nil
flowFile = session.write(flowFile, jrubyStreamCallback)
end
应用场景4 : 处理脚本处理过程中的错误.脚本中发生错误（通过数据验证或抛出异常），并且您希望脚本正常处理它。
方案 : 对于异常，使用脚本语言的异常处理机制（通常是try / catch块）。对于数据验证，您可以使用类似的方法，但定义一个布尔变量，如“valid”和if / else子句。ExecuteScript定义“成功”和“失败”关系; 通常，您的处理将“好”流文件转移到成功，“坏”流文件转换为失败（在后一种情况下记录错误）.
Groovy
flowFile = session.get()
if(!flowFile) return
try {
// Something that might throw an exception here
// Last operation is transfer to success (failures handled in the catch block)
session.transfer(flowFile, REL_SUCCESS)
} catch(e) {
log.error('Something went wrong', e)
session.transfer(flowFile, REL_FAILURE)
}Jython
flowFile = session.get()
if(flowFile != None):
try:
# Something that might throw an exception here
# Last operation is transfer to success (failures handled in the catch block)
session.transfer(flowFile, REL_SUCCESS)
except:
log.error('Something went wrong', e)
session.transfer(flowFile, REL_FAILURE)
# implicit return at the endJavaScript
var flowFile = session.get();
if(flowFile != null) {
try {
// Something that might throw an exception here
// Last operation is transfer to success (failures handled in the catch block)
session.transfer(flowFile, REL_SUCCESS)
} catch(e) {
log.error('Something went wrong', e)
session.transfer(flowFile, REL_FAILURE)
}
}JRuby
flowFile = session.get()
if flowFile != nil
begin
# Something that might raise an exception here
# Last operation is transfer to success (failures handled in the rescue block)
session.transfer(flowFile, REL_SUCCESS)
rescue Exception => e
log.error('Something went wrong', e)
session.transfer(flowFile, REL_FAILURE)
end
end
希望本文描述了FlowFile I / O的基础知识和错误处理，但欢迎提出建议和改进！在本系列的下一篇文章中，我将讨论一些更高级的功能，例如动态属性，模块，状态管理以及访问/使用Controller Services.
原文连接:https://community.hortonworks.com/articles/75545/executescript-cookbook-part-2.html