/** * Validate the provided expression. * * @param name parameter name * @param expr expression * @param expectedReturnType expected result type * @param context forge initialization context * @return validated expression node * @throws ExprValidationException when validation failed */ public static ExprNode validate(String name, ExprNode expr, Class expectedReturnType, DataFlowOpForgeInitializeContext context) throws ExprValidationException { if (expr == null) { return null; } return validate(name, expr, null, expectedReturnType, context); }
public DataFlowOperator operator(DataFlowOpInitializeContext context) { String propOneText = DataFlowParameterResolution.resolveStringOptional("propOne", propOne, context); String propTwoText = DataFlowParameterResolution.resolveStringOptional("propTwo", propTwo, context); String propThreeText = DataFlowParameterResolution.resolveStringOptional("propThree", propThree, context); return new MyOp(this, propOneText, propTwoText, propThreeText); }
public DataFlowOperator operator(DataFlowOpInitializeContext context) { String fileName = DataFlowParameterResolution.resolveStringRequired("file", file, context); boolean classPathFileFlag = DataFlowParameterResolution.resolveWithDefault("classpathFile", classpathFile, false, boolean.class, context); boolean appendFlag = DataFlowParameterResolution.resolveWithDefault("append", append, false, boolean.class, context); return new FileSinkCSV(this, fileName, classPathFileFlag, appendFlag); }
void evaluateAndSet(AMQPSettingsValuesBase values, DataFlowOpInitializeContext context) { values.setHost(DataFlowParameterResolution.resolveStringRequired("host", host, context)); values.setPort(DataFlowParameterResolution.resolveWithDefault("port", port, -1, int.class, context)); values.setUsername(DataFlowParameterResolution.resolveStringOptional("username", username, context)); values.setPassword(DataFlowParameterResolution.resolveStringOptional("password", password, context)); values.setVhost(DataFlowParameterResolution.resolveStringOptional("vhost", vhost, context)); values.setQueueName(DataFlowParameterResolution.resolveStringRequired("queueName", queueName, context)); values.setExchange(DataFlowParameterResolution.resolveStringOptional("exchange", exchange, context)); values.setRoutingKey(DataFlowParameterResolution.resolveStringOptional("routingKey", routingKey, context)); values.setLogMessages(DataFlowParameterResolution.resolveWithDefault("logMessages", logMessages, false, boolean.class, context)); values.setWaitMSecNextMsg(DataFlowParameterResolution.resolveWithDefault("waitMSecNextMsg", waitMSecNextMsg, 1L, long.class, context)); values.setDeclareDurable(DataFlowParameterResolution.resolveWithDefault("declareDurable", declareDurable, false, boolean.class, context)); values.setDeclareExclusive(DataFlowParameterResolution.resolveWithDefault("declareExclusive", declareExclusive, false, boolean.class, context)); values.setDeclareAutoDelete(DataFlowParameterResolution.resolveWithDefault("declareAutoDelete", declareAutoDelete, true, boolean.class, context)); values.setDeclareAdditionalArgs(DataFlowParameterResolution.resolveMap("declareAutoDelete", declareAdditionalArgs, context)); }
public DataFlowOperator operator(DataFlowOpInitializeContext context) { String statementDeploymentIdParam = DataFlowParameterResolution.resolveStringOptional("statementDeploymentId", statementDeploymentId, context); String statementNameParam = DataFlowParameterResolution.resolveStringOptional("statementName", statementName, context); EPDataFlowEPStatementFilter statementFilterInstance = DataFlowParameterResolution.resolveOptionalInstance("statementFilter", statementFilter, EPDataFlowEPStatementFilter.class, context); EPDataFlowIRStreamCollector collectorInstance = DataFlowParameterResolution.resolveOptionalInstance("collector", collector, EPDataFlowIRStreamCollector.class, context); if (statementNameParam == null && statementFilterInstance == null) { throw new EPException("Failed to find required 'statementName' or 'statementFilter' parameter"); } return new EPStatementSourceOp(this, context.getAgentInstanceContext(), statementDeploymentIdParam, statementNameParam, statementFilterInstance, collectorInstance); }
public AMQPSettingsSourceValues evaluate(DataFlowOpInitializeContext context) { AMQPSettingsSourceValues values = new AMQPSettingsSourceValues(); super.evaluateAndSet(values, context); values.setCollector(DataFlowParameterResolution.resolveOptionalInstance("collector", collector, AMQPToObjectCollector.class, context)); values.setPrefetchCount(DataFlowParameterResolution.resolveWithDefault("prefetchCount", prefetchCount, 100, int.class, context)); values.setConsumeAutoAck(DataFlowParameterResolution.resolveWithDefault("consumeAutoAck", consumeAutoAck, true, boolean.class, context)); return values; }
public DataFlowOperator operator(DataFlowOpInitializeContext context) { EPDataFlowEventCollector collectorInstance = DataFlowParameterResolution.resolveOptionalInstance("collector", collector, EPDataFlowEventCollector.class, context); return new EventBusSinkOp(this, context.getAgentInstanceContext(), collectorInstance); }
/** * Resolve a string value by first looking at the parameter value provider and by using the evaluator if one was provided * or returning null if no value was found. * * @param name parameter name * @param optionalEvaluator evaluator * @param context initialization context * @return value * @throws EPException if no value was found */ public static String resolveStringOptional(String name, ExprEvaluator optionalEvaluator, DataFlowOpInitializeContext context) { String resolvedFromProvider = tryParameterProvider(name, context, String.class); if (resolvedFromProvider != null) { return resolvedFromProvider; } if (optionalEvaluator == null) { return null; } return (String) optionalEvaluator.evaluate(null, true, context.getAgentInstanceContext()); }
public DataFlowOperator operator(DataFlowOpInitializeContext context) { long iterationsCount = DataFlowParameterResolution.resolveNumber("iterations", iterations, 0, context).longValue(); double initialDelaySec = DataFlowParameterResolution.resolveNumber("initialDelay", initialDelay, 0, context).doubleValue(); long initialDelayMSec = (long) (initialDelaySec * 1000); double intervalSec = DataFlowParameterResolution.resolveNumber("interval", interval, 0, context).doubleValue(); long intervalMSec = (long) (intervalSec * 1000); return new BeaconSourceOp(this, iterationsCount, initialDelayMSec, intervalMSec, context.getAdditionalParameters()); }
/** * Validate the provided expression. * * @param name parameter name * @param eventType event type * @param expr expression * @param expectedReturnType expected result type * @param context forge initialization context * @return validated expression node * @throws ExprValidationException when validation failed */ public static ExprNode validate(String name, ExprNode expr, EventType eventType, Class expectedReturnType, DataFlowOpForgeInitializeContext context) throws ExprValidationException { if (expr == null) { return null; } ExprNode validated = EPLValidationUtil.validateSimpleGetSubtree(ExprNodeOrigin.DATAFLOWFILTER, expr, eventType, false, context.getStatementRawInfo(), context.getServices()); validateReturnType(name, validated, expectedReturnType); return validated; }
public DataFlowOperator operator(DataFlowOpInitializeContext context) { String fileName = DataFlowParameterResolution.resolveStringRequired("file", file, context); boolean classPathFileFlag = DataFlowParameterResolution.resolveWithDefault("classpathFile", classpathFile, false, boolean.class, context); boolean appendFlag = DataFlowParameterResolution.resolveWithDefault("append", append, false, boolean.class, context); return new FileSinkCSV(this, fileName, classPathFileFlag, appendFlag); }
protected void validate(DataFlowOpForgeInitializeContext context) throws ExprValidationException { host = DataFlowParameterValidation.validate("host", host, String.class, context); port = DataFlowParameterValidation.validate("port", port, int.class, context); username = DataFlowParameterValidation.validate("username", username, String.class, context); password = DataFlowParameterValidation.validate("password", password, String.class, context); vhost = DataFlowParameterValidation.validate("vhost", vhost, String.class, context); queueName = DataFlowParameterValidation.validate("queueName", queueName, String.class, context); exchange = DataFlowParameterValidation.validate("exchange", exchange, String.class, context); routingKey = DataFlowParameterValidation.validate("routingKey", routingKey, String.class, context); logMessages = DataFlowParameterValidation.validate("logMessages", logMessages, boolean.class, context); waitMSecNextMsg = DataFlowParameterValidation.validate("waitMSecNextMsg", waitMSecNextMsg, long.class, context); declareDurable = DataFlowParameterValidation.validate("declareDurable", declareDurable, boolean.class, context); declareExclusive = DataFlowParameterValidation.validate("declareExclusive", declareExclusive, boolean.class, context); declareAutoDelete = DataFlowParameterValidation.validate("declareAutoDelete", declareAutoDelete, boolean.class, context); }
public DataFlowOperator operator(DataFlowOpInitializeContext context) { String nameText = DataFlowParameterResolution.resolveStringOptional("name", name, context); return new EmitterOp(nameText); }
public DataFlowOperator operator(DataFlowOpInitializeContext context) { EPDataFlowEventBeanCollector collectorInstance = DataFlowParameterResolution.resolveOptionalInstance("collector", collector, EPDataFlowEventBeanCollector.class, context); return new EventBusSourceOp(this, context.getAgentInstanceContext(), collectorInstance); }
/** * Resolve a number value by first looking at the parameter value provider and by using the evaluator if one was provided, * returning the default value if no value was found and no evaluator was provided. * * @param name parameter name * @param optionalEvaluator evaluator * @param defaultValue default * @param context initialization context * @return value */ public static Number resolveNumber(String name, ExprEvaluator optionalEvaluator, Number defaultValue, DataFlowOpInitializeContext context) { Number resolvedFromProvider = tryParameterProvider(name, context, Number.class); if (resolvedFromProvider != null) { return resolvedFromProvider; } if (optionalEvaluator == null) { return defaultValue; } Number value = (Number) optionalEvaluator.evaluate(null, true, context.getAgentInstanceContext()); if (value == null) { throw new EPException("Parameter '" + name + "' is null and is expected to have a value"); } return value; }
public void validate(DataFlowOpForgeInitializeContext context) throws ExprValidationException { super.validate(context); prefetchCount = DataFlowParameterValidation.validate("prefetchCount", prefetchCount, int.class, context); consumeAutoAck = DataFlowParameterValidation.validate("consumeAutoAck", consumeAutoAck, boolean.class, context); }
public AMQPSettingsSinkValues evaluate(DataFlowOpInitializeContext context) { AMQPSettingsSinkValues values = new AMQPSettingsSinkValues(); super.evaluateAndSet(values, context); values.setCollector(DataFlowParameterResolution.resolveOptionalInstance("collector", collector, ObjectToAMQPCollector.class, context)); return values; }
/** * Resolve a string value by first looking at the parameter value provider and by using the evaluator if one was provided, * throwing an exception if no value was provided. * * @param name parameter name * @param optionalEvaluator evaluator * @param context initialization context * @return value * @throws EPException if no value was found */ public static String resolveStringRequired(String name, ExprEvaluator optionalEvaluator, DataFlowOpInitializeContext context) { String resolvedFromProvider = tryParameterProvider(name, context, String.class); if (resolvedFromProvider != null) { return resolvedFromProvider; } if (optionalEvaluator == null) { throw new EPException("Parameter by name '" + name + "' has no value"); } String value = (String) optionalEvaluator.evaluate(null, true, context.getAgentInstanceContext()); if (value == null) { throw new EPException("Parameter by name '" + name + "' has a null value"); } return value; }
public DataFlowOpForgeInitializeResult initializeForge(DataFlowOpForgeInitializeContext context) throws ExprValidationException { if (!context.getOutputPorts().isEmpty()) { throw new IllegalArgumentException("LogSink operator does not provide an output stream"); } eventTypes = new EventType[context.getInputPorts().size()]; for (Map.Entry<Integer, DataFlowOpInputPort> entry : context.getInputPorts().entrySet()) { eventTypes[entry.getKey()] = entry.getValue().getTypeDesc().getEventType(); } title = DataFlowParameterValidation.validate("title", title, String.class, context); layout = DataFlowParameterValidation.validate("layout", layout, String.class, context); format = DataFlowParameterValidation.validate("format", format, String.class, context); log = DataFlowParameterValidation.validate("log", log, boolean.class, context); linefeed = DataFlowParameterValidation.validate("linefeed", linefeed, boolean.class, context); return null; }
public DataFlowOpForgeInitializeResult initializeForge(DataFlowOpForgeInitializeContext context) throws ExprValidationException { iterations = DataFlowParameterValidation.validate("iterations", iterations, Number.class, context); initialDelay = DataFlowParameterValidation.validate("initialDelay", initialDelay, Number.class, context); interval = DataFlowParameterValidation.validate("interval", interval, Number.class, context); if (context.getOutputPorts().size() != 1) { throw new IllegalArgumentException("BeaconSource operator requires one output stream but produces " + context.getOutputPorts().size() + " streams"); } DataFlowOpOutputPort port = context.getOutputPorts().get(0); // Check if a type is declared if (port.getOptionalDeclaredType() == null || port.getOptionalDeclaredType().getEventType() == null) { return initializeTypeUndeclared(context); } return initializeTypeDeclared(port, context); }