You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by dw...@apache.org on 2018/11/28 14:04:34 UTC

[flink] branch master updated: [FLINK-8159] [cep] Pattern(Flat)SelectFunctions should support RichFunction interface [FLINK-6938] [cep] IterativeCondition should support RichFunction interface

This is an automated email from the ASF dual-hosted git repository.

dwysakowicz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/flink.git


The following commit(s) were added to refs/heads/master by this push:
     new 1de3416  [FLINK-8159] [cep] Pattern(Flat)SelectFunctions should support RichFunction interface [FLINK-6938] [cep] IterativeCondition should support RichFunction interface
1de3416 is described below

commit 1de341630f848528b966cfee89fc812a56991a99
Author: Dian Fu <fu...@alibaba-inc.com>
AuthorDate: Thu Nov 15 22:58:51 2018 +0800

    [FLINK-8159] [cep] Pattern(Flat)SelectFunctions should support RichFunction interface
    [FLINK-6938] [cep] IterativeCondition should support RichFunction interface
    
    This closes #7110
---
 .../flink/cep/scala/pattern/PatternTest.scala      |   2 +-
 .../org/apache/flink/cep/CepRuntimeContext.java    | 196 +++++++++++++
 .../flink/cep/RichPatternFlatSelectFunction.java   |  57 ++++
 .../flink/cep/RichPatternSelectFunction.java       |  56 ++++
 .../apache/flink/cep/nfa/compiler/NFACompiler.java |  26 +-
 .../operator/AbstractKeyedCEPPatternOperator.java  |  34 +++
 .../java/org/apache/flink/cep/pattern/Pattern.java |  17 +-
 .../flink/cep/pattern/conditions/AndCondition.java |   5 +
 .../cep/pattern/conditions/BooleanConditions.java  |   3 +
 .../flink/cep/pattern/conditions/NotCondition.java |   6 +
 .../flink/cep/pattern/conditions/OrCondition.java  |   5 +
 .../{AndCondition.java => RichAndCondition.java}   |  23 +-
 .../RichCompositeIterativeCondition.java           |  75 +++++
 .../pattern/conditions/RichIterativeCondition.java |  81 ++++++
 .../{NotCondition.java => RichNotCondition.java}   |  16 +-
 .../{OrCondition.java => RichOrCondition.java}     |  23 +-
 .../cep/pattern/conditions/SimpleCondition.java    |   2 +
 .../cep/pattern/conditions/SubtypeCondition.java   |   2 +
 .../test/java/org/apache/flink/cep/CEPITCase.java  | 168 +++++++++++
 .../apache/flink/cep/CepRuntimeContextTest.java    | 321 +++++++++++++++++++++
 .../org/apache/flink/cep/pattern/PatternTest.java  |  24 +-
 21 files changed, 1085 insertions(+), 57 deletions(-)

diff --git a/flink-libraries/flink-cep-scala/src/test/scala/org/apache/flink/cep/scala/pattern/PatternTest.scala b/flink-libraries/flink-cep-scala/src/test/scala/org/apache/flink/cep/scala/pattern/PatternTest.scala
index 33d24de..91a1503 100644
--- a/flink-libraries/flink-cep-scala/src/test/scala/org/apache/flink/cep/scala/pattern/PatternTest.scala
+++ b/flink-libraries/flink-cep-scala/src/test/scala/org/apache/flink/cep/scala/pattern/PatternTest.scala
@@ -113,7 +113,7 @@ class PatternTest {
 
     assertTrue(pattern.getCondition.isDefined)
     assertTrue(previous.getCondition.isDefined)
-    assertFalse(preprevious.getCondition.isDefined)
+    assertTrue(preprevious.getCondition.isDefined)
 
     assertEquals(pattern.getName, "end")
     assertEquals(previous.getName, "next")
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/CepRuntimeContext.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/CepRuntimeContext.java
new file mode 100644
index 0000000..ff6e610
--- /dev/null
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/CepRuntimeContext.java
@@ -0,0 +1,196 @@
+/*
+ * 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.flink.cep;
+
+import org.apache.flink.api.common.ExecutionConfig;
+import org.apache.flink.api.common.accumulators.Accumulator;
+import org.apache.flink.api.common.accumulators.DoubleCounter;
+import org.apache.flink.api.common.accumulators.Histogram;
+import org.apache.flink.api.common.accumulators.IntCounter;
+import org.apache.flink.api.common.accumulators.LongCounter;
+import org.apache.flink.api.common.cache.DistributedCache;
+import org.apache.flink.api.common.functions.BroadcastVariableInitializer;
+import org.apache.flink.api.common.functions.RuntimeContext;
+import org.apache.flink.api.common.state.AggregatingState;
+import org.apache.flink.api.common.state.AggregatingStateDescriptor;
+import org.apache.flink.api.common.state.FoldingState;
+import org.apache.flink.api.common.state.FoldingStateDescriptor;
+import org.apache.flink.api.common.state.ListState;
+import org.apache.flink.api.common.state.ListStateDescriptor;
+import org.apache.flink.api.common.state.MapState;
+import org.apache.flink.api.common.state.MapStateDescriptor;
+import org.apache.flink.api.common.state.ReducingState;
+import org.apache.flink.api.common.state.ReducingStateDescriptor;
+import org.apache.flink.api.common.state.ValueState;
+import org.apache.flink.api.common.state.ValueStateDescriptor;
+import org.apache.flink.metrics.MetricGroup;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A wrapper class for pattern select function and iterative condition function's {@link RuntimeContext}.
+ * The runtime context only supports basic operations. Consequently, state access, accumulators,
+ * broadcast variables and the distributed cache are disabled.
+ */
+public class CepRuntimeContext implements RuntimeContext {
+
+	private final RuntimeContext runtimeContext;
+
+	public CepRuntimeContext(RuntimeContext runtimeContext) {
+		this.runtimeContext = runtimeContext;
+	}
+
+	@Override
+	public String getTaskName() {
+		return runtimeContext.getTaskName();
+	}
+
+	@Override
+	public MetricGroup getMetricGroup() {
+		return runtimeContext.getMetricGroup();
+	}
+
+	@Override
+	public int getNumberOfParallelSubtasks() {
+		return runtimeContext.getNumberOfParallelSubtasks();
+	}
+
+	@Override
+	public int getMaxNumberOfParallelSubtasks() {
+		return runtimeContext.getMaxNumberOfParallelSubtasks();
+	}
+
+	@Override
+	public int getIndexOfThisSubtask() {
+		return runtimeContext.getIndexOfThisSubtask();
+	}
+
+	@Override
+	public int getAttemptNumber() {
+		return runtimeContext.getAttemptNumber();
+	}
+
+	@Override
+	public String getTaskNameWithSubtasks() {
+		return runtimeContext.getTaskNameWithSubtasks();
+	}
+
+	@Override
+	public ExecutionConfig getExecutionConfig() {
+		return runtimeContext.getExecutionConfig();
+	}
+
+	@Override
+	public ClassLoader getUserCodeClassLoader() {
+		return runtimeContext.getUserCodeClassLoader();
+	}
+
+	// -----------------------------------------------------------------------------------
+	// Unsupported operations
+	// -----------------------------------------------------------------------------------
+
+	@Override
+	public <V, A extends Serializable> void addAccumulator(
+		String name, Accumulator<V, A> accumulator) {
+		throw new UnsupportedOperationException("Accumulators are not supported.");
+	}
+
+	@Override
+	public <V, A extends Serializable> Accumulator<V, A> getAccumulator(String name) {
+		throw new UnsupportedOperationException("Accumulators are not supported.");
+	}
+
+	@Override
+	public Map<String, Accumulator<?, ?>> getAllAccumulators() {
+		throw new UnsupportedOperationException("Accumulators are not supported.");
+	}
+
+	@Override
+	public IntCounter getIntCounter(String name) {
+		throw new UnsupportedOperationException("Int counters are not supported.");
+	}
+
+	@Override
+	public LongCounter getLongCounter(String name) {
+		throw new UnsupportedOperationException("Long counters are not supported.");
+	}
+
+	@Override
+	public DoubleCounter getDoubleCounter(String name) {
+		throw new UnsupportedOperationException("Double counters are not supported.");
+	}
+
+	@Override
+	public Histogram getHistogram(String name) {
+		throw new UnsupportedOperationException("Histograms are not supported.");
+	}
+
+	@Override
+	public boolean hasBroadcastVariable(String name) {
+		throw new UnsupportedOperationException("Broadcast variables are not supported.");
+	}
+
+	@Override
+	public <RT> List<RT> getBroadcastVariable(String name) {
+		throw new UnsupportedOperationException("Broadcast variables are not supported.");
+	}
+
+	@Override
+	public <T, C> C getBroadcastVariableWithInitializer(
+		String name, BroadcastVariableInitializer<T, C> initializer) {
+		throw new UnsupportedOperationException("Broadcast variables are not supported.");
+	}
+
+	@Override
+	public DistributedCache getDistributedCache() {
+		throw new UnsupportedOperationException("Distributed cache is not supported.");
+	}
+
+	@Override
+	public <T> ValueState<T> getState(ValueStateDescriptor<T> stateProperties) {
+		throw new UnsupportedOperationException("State is not supported.");
+	}
+
+	@Override
+	public <T> ListState<T> getListState(ListStateDescriptor<T> stateProperties) {
+		throw new UnsupportedOperationException("State is not supported.");
+	}
+
+	@Override
+	public <T> ReducingState<T> getReducingState(ReducingStateDescriptor<T> stateProperties) {
+		throw new UnsupportedOperationException("State is not supported.");
+	}
+
+	@Override
+	public <IN, ACC, OUT> AggregatingState<IN, OUT> getAggregatingState(AggregatingStateDescriptor<IN, ACC, OUT> stateProperties) {
+		throw new UnsupportedOperationException("State is not supported.");
+	}
+
+	@Override
+	public <T, ACC> FoldingState<T, ACC> getFoldingState(FoldingStateDescriptor<T, ACC> stateProperties) {
+		throw new UnsupportedOperationException("State is not supported.");
+	}
+
+	@Override
+	public <UK, UV> MapState<UK, UV> getMapState(MapStateDescriptor<UK, UV> stateProperties) {
+		throw new UnsupportedOperationException("State is not supported.");
+	}
+}
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/RichPatternFlatSelectFunction.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/RichPatternFlatSelectFunction.java
new file mode 100644
index 0000000..a2b89c3
--- /dev/null
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/RichPatternFlatSelectFunction.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.flink.cep;
+
+import org.apache.flink.api.common.functions.AbstractRichFunction;
+import org.apache.flink.api.common.functions.RichFunction;
+import org.apache.flink.api.common.functions.RuntimeContext;
+import org.apache.flink.util.Collector;
+import org.apache.flink.util.Preconditions;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Rich variant of the {@link PatternFlatSelectFunction}. As a {@link RichFunction}, it gives access to the
+ * {@link org.apache.flink.api.common.functions.RuntimeContext} and provides setup and teardown methods:
+ * {@link RichFunction#open(org.apache.flink.configuration.Configuration)} and
+ * {@link RichFunction#close()}.
+ *
+ * @param <IN> Type of the input elements
+ * @param <OUT> Type of the output element
+ */
+public abstract class RichPatternFlatSelectFunction<IN, OUT>
+		extends AbstractRichFunction
+		implements PatternFlatSelectFunction<IN, OUT> {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public void setRuntimeContext(RuntimeContext runtimeContext) {
+		Preconditions.checkNotNull(runtimeContext);
+
+		if (runtimeContext instanceof CepRuntimeContext) {
+			super.setRuntimeContext(runtimeContext);
+		} else {
+			super.setRuntimeContext(new CepRuntimeContext(runtimeContext));
+		}
+	}
+
+	public abstract void flatSelect(Map<String, List<IN>> pattern, Collector<OUT> out) throws Exception;
+}
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/RichPatternSelectFunction.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/RichPatternSelectFunction.java
new file mode 100644
index 0000000..ce694a3
--- /dev/null
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/RichPatternSelectFunction.java
@@ -0,0 +1,56 @@
+/*
+ * 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.flink.cep;
+
+import org.apache.flink.api.common.functions.AbstractRichFunction;
+import org.apache.flink.api.common.functions.RichFunction;
+import org.apache.flink.api.common.functions.RuntimeContext;
+import org.apache.flink.util.Preconditions;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Rich variant of the {@link PatternSelectFunction}. As a {@link RichFunction}, it gives access to the
+ * {@link org.apache.flink.api.common.functions.RuntimeContext} and provides setup and teardown methods:
+ * {@link RichFunction#open(org.apache.flink.configuration.Configuration)} and
+ * {@link RichFunction#close()}.
+ *
+ * @param <IN> Type of the input elements
+ * @param <OUT> Type of the output element
+ */
+public abstract class RichPatternSelectFunction<IN, OUT>
+		extends AbstractRichFunction
+		implements PatternSelectFunction<IN, OUT> {
+
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public void setRuntimeContext(RuntimeContext runtimeContext) {
+		Preconditions.checkNotNull(runtimeContext);
+
+		if (runtimeContext instanceof CepRuntimeContext) {
+			super.setRuntimeContext(runtimeContext);
+		} else {
+			super.setRuntimeContext(new CepRuntimeContext(runtimeContext));
+		}
+	}
+
+	public abstract OUT select(Map<String, List<IN>> pattern) throws Exception;
+}
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/nfa/compiler/NFACompiler.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/nfa/compiler/NFACompiler.java
index ed2ff2e..bc692f2 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/nfa/compiler/NFACompiler.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/nfa/compiler/NFACompiler.java
@@ -29,10 +29,10 @@ import org.apache.flink.cep.pattern.MalformedPatternException;
 import org.apache.flink.cep.pattern.Pattern;
 import org.apache.flink.cep.pattern.Quantifier;
 import org.apache.flink.cep.pattern.Quantifier.Times;
-import org.apache.flink.cep.pattern.conditions.AndCondition;
 import org.apache.flink.cep.pattern.conditions.BooleanConditions;
 import org.apache.flink.cep.pattern.conditions.IterativeCondition;
-import org.apache.flink.cep.pattern.conditions.NotCondition;
+import org.apache.flink.cep.pattern.conditions.RichAndCondition;
+import org.apache.flink.cep.pattern.conditions.RichNotCondition;
 import org.apache.flink.streaming.api.windowing.time.Time;
 
 import java.io.Serializable;
@@ -288,9 +288,9 @@ public class NFACompiler {
 
 					if (lastSink.isFinal()) {
 						//so that the proceed to final is not fired
-						notNext.addIgnore(lastSink, new NotCondition<>(notCondition));
+						notNext.addIgnore(lastSink, new RichNotCondition<>(notCondition));
 					} else {
-						notNext.addProceed(lastSink, new NotCondition<>(notCondition));
+						notNext.addProceed(lastSink, new RichNotCondition<>(notCondition));
 					}
 					notNext.addProceed(stopState, notCondition);
 					lastSink = notNext;
@@ -612,11 +612,11 @@ public class NFACompiler {
 					if (untilCondition != null) {
 						singletonState.addProceed(
 							originalStateMap.get(proceedState.getName()),
-							new AndCondition<>(proceedCondition, untilCondition));
+							new RichAndCondition<>(proceedCondition, untilCondition));
 					}
 					singletonState.addProceed(proceedState,
 						untilCondition != null
-							? new AndCondition<>(proceedCondition, new NotCondition<>(untilCondition))
+							? new RichAndCondition<>(proceedCondition, new RichNotCondition<>(untilCondition))
 							: proceedCondition);
 				} else {
 					singletonState.addProceed(proceedState, proceedCondition);
@@ -734,12 +734,12 @@ public class NFACompiler {
 			if (currentPattern.getQuantifier().hasProperty(Quantifier.QuantifierProperty.GREEDY)) {
 				if (untilCondition != null) {
 					State<T> sinkStateCopy = copy(sinkState);
-					loopingState.addProceed(sinkStateCopy, new AndCondition<>(proceedCondition, untilCondition));
+					loopingState.addProceed(sinkStateCopy, new RichAndCondition<>(proceedCondition, untilCondition));
 					originalStateMap.put(sinkState.getName(), sinkStateCopy);
 				}
 				loopingState.addProceed(sinkState,
 					untilCondition != null
-						? new AndCondition<>(proceedCondition, new NotCondition<>(untilCondition))
+						? new RichAndCondition<>(proceedCondition, new RichNotCondition<>(untilCondition))
 						: proceedCondition);
 				updateWithGreedyCondition(sinkState, getTakeCondition(currentPattern));
 			} else {
@@ -774,9 +774,9 @@ public class NFACompiler {
 				IterativeCondition<T> untilCondition,
 				boolean isTakeCondition) {
 			if (untilCondition != null && condition != null) {
-				return new AndCondition<>(new NotCondition<>(untilCondition), condition);
+				return new RichAndCondition<>(new RichNotCondition<>(untilCondition), condition);
 			} else if (untilCondition != null && isTakeCondition) {
-				return new NotCondition<>(untilCondition);
+				return new RichNotCondition<>(untilCondition);
 			}
 
 			return condition;
@@ -802,7 +802,7 @@ public class NFACompiler {
 					innerIgnoreCondition = null;
 					break;
 				case SKIP_TILL_NEXT:
-					innerIgnoreCondition = new NotCondition<>((IterativeCondition<T>) pattern.getCondition());
+					innerIgnoreCondition = new RichNotCondition<>((IterativeCondition<T>) pattern.getCondition());
 					break;
 				case SKIP_TILL_ANY:
 					innerIgnoreCondition = BooleanConditions.trueFunction();
@@ -843,7 +843,7 @@ public class NFACompiler {
 					ignoreCondition = null;
 					break;
 				case SKIP_TILL_NEXT:
-					ignoreCondition = new NotCondition<>((IterativeCondition<T>) pattern.getCondition());
+					ignoreCondition = new RichNotCondition<>((IterativeCondition<T>) pattern.getCondition());
 					break;
 				case SKIP_TILL_ANY:
 					ignoreCondition = BooleanConditions.trueFunction();
@@ -896,7 +896,7 @@ public class NFACompiler {
 			IterativeCondition<T> takeCondition) {
 			for (StateTransition<T> stateTransition : state.getStateTransitions()) {
 				stateTransition.setCondition(
-					new AndCondition<>(stateTransition.getCondition(), new NotCondition<>(takeCondition)));
+					new RichAndCondition<>(stateTransition.getCondition(), new RichNotCondition<>(takeCondition)));
 			}
 		}
 	}
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/operator/AbstractKeyedCEPPatternOperator.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/operator/AbstractKeyedCEPPatternOperator.java
index b57c3fe..c603741 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/operator/AbstractKeyedCEPPatternOperator.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/operator/AbstractKeyedCEPPatternOperator.java
@@ -20,6 +20,7 @@ package org.apache.flink.cep.operator;
 
 import org.apache.flink.annotation.VisibleForTesting;
 import org.apache.flink.api.common.functions.Function;
+import org.apache.flink.api.common.functions.util.FunctionUtils;
 import org.apache.flink.api.common.state.MapState;
 import org.apache.flink.api.common.state.MapStateDescriptor;
 import org.apache.flink.api.common.state.ValueState;
@@ -33,10 +34,14 @@ import org.apache.flink.cep.nfa.NFA;
 import org.apache.flink.cep.nfa.NFA.MigratedNFA;
 import org.apache.flink.cep.nfa.NFAState;
 import org.apache.flink.cep.nfa.NFAStateSerializer;
+import org.apache.flink.cep.nfa.State;
+import org.apache.flink.cep.nfa.StateTransition;
 import org.apache.flink.cep.nfa.aftermatch.AfterMatchSkipStrategy;
 import org.apache.flink.cep.nfa.compiler.NFACompiler;
 import org.apache.flink.cep.nfa.sharedbuffer.SharedBuffer;
 import org.apache.flink.cep.nfa.sharedbuffer.SharedBufferAccessor;
+import org.apache.flink.cep.pattern.conditions.IterativeCondition;
+import org.apache.flink.configuration.Configuration;
 import org.apache.flink.runtime.state.KeyedStateFunction;
 import org.apache.flink.runtime.state.StateInitializationContext;
 import org.apache.flink.runtime.state.VoidNamespace;
@@ -185,6 +190,15 @@ public abstract class AbstractKeyedCEPPatternOperator<IN, KEY, OUT, F extends Fu
 				this);
 
 		this.nfa = nfaFactory.createNFA();
+
+		openNFA(nfa);
+	}
+
+	@Override
+	public void close() throws Exception {
+		super.close();
+
+		closeNFA(nfa);
 	}
 
 	@Override
@@ -395,6 +409,26 @@ public abstract class AbstractKeyedCEPPatternOperator<IN, KEY, OUT, F extends Fu
 		}
 	}
 
+	private void openNFA(NFA<IN> nfa) throws Exception {
+		Configuration conf = new Configuration();
+		for (State<IN> state : nfa.getStates()) {
+			for (StateTransition<IN> transition : state.getStateTransitions()) {
+				IterativeCondition condition = transition.getCondition();
+				FunctionUtils.setFunctionRuntimeContext(condition, getRuntimeContext());
+				FunctionUtils.openFunction(condition, conf);
+			}
+		}
+	}
+
+	private void closeNFA(NFA<IN> nfa) throws Exception {
+		for (State<IN> state : nfa.getStates()) {
+			for (StateTransition<IN> transition : state.getStateTransitions()) {
+				IterativeCondition condition = transition.getCondition();
+				FunctionUtils.closeFunction(condition);
+			}
+		}
+	}
+
 	protected abstract void processMatchedSequences(Iterable<Map<String, List<IN>>> matchingSequences, long timestamp) throws Exception;
 
 	protected void processTimedOutSequences(
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/Pattern.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/Pattern.java
index 6ad9d9a..6423676 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/Pattern.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/Pattern.java
@@ -23,9 +23,10 @@ import org.apache.flink.cep.nfa.NFA;
 import org.apache.flink.cep.nfa.aftermatch.AfterMatchSkipStrategy;
 import org.apache.flink.cep.pattern.Quantifier.ConsumingStrategy;
 import org.apache.flink.cep.pattern.Quantifier.Times;
-import org.apache.flink.cep.pattern.conditions.AndCondition;
+import org.apache.flink.cep.pattern.conditions.BooleanConditions;
 import org.apache.flink.cep.pattern.conditions.IterativeCondition;
-import org.apache.flink.cep.pattern.conditions.OrCondition;
+import org.apache.flink.cep.pattern.conditions.RichAndCondition;
+import org.apache.flink.cep.pattern.conditions.RichOrCondition;
 import org.apache.flink.cep.pattern.conditions.SubtypeCondition;
 import org.apache.flink.streaming.api.windowing.time.Time;
 import org.apache.flink.util.Preconditions;
@@ -105,7 +106,11 @@ public class Pattern<T, F extends T> {
 	}
 
 	public IterativeCondition<F> getCondition() {
-		return condition;
+		if (condition != null) {
+			return condition;
+		} else {
+			return BooleanConditions.trueFunction();
+		}
 	}
 
 	public IterativeCondition<F> getUntilCondition() {
@@ -154,7 +159,7 @@ public class Pattern<T, F extends T> {
 		if (this.condition == null) {
 			this.condition = condition;
 		} else {
-			this.condition = new AndCondition<>(this.condition, condition);
+			this.condition = new RichAndCondition<>(this.condition, condition);
 		}
 		return this;
 	}
@@ -177,7 +182,7 @@ public class Pattern<T, F extends T> {
 		if (this.condition == null) {
 			this.condition = condition;
 		} else {
-			this.condition = new OrCondition<>(this.condition, condition);
+			this.condition = new RichOrCondition<>(this.condition, condition);
 		}
 		return this;
 	}
@@ -196,7 +201,7 @@ public class Pattern<T, F extends T> {
 		if (condition == null) {
 			this.condition = new SubtypeCondition<F>(subtypeClass);
 		} else {
-			this.condition = new AndCondition<>(condition, new SubtypeCondition<F>(subtypeClass));
+			this.condition = new RichAndCondition<>(condition, new SubtypeCondition<F>(subtypeClass));
 		}
 
 		@SuppressWarnings("unchecked")
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/AndCondition.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/AndCondition.java
index ac34c41..4622417 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/AndCondition.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/AndCondition.java
@@ -18,6 +18,7 @@
 
 package org.apache.flink.cep.pattern.conditions;
 
+import org.apache.flink.annotation.Internal;
 import org.apache.flink.util.Preconditions;
 
 /**
@@ -25,7 +26,11 @@ import org.apache.flink.util.Preconditions;
  * {@code AND} and returns {@code true} if both are {@code true}.
  *
  * @param <T> Type of the element to filter
+ * @deprecated Please use {@link RichAndCondition} instead. This class exists just for
+ * backwards compatibility and will be removed in FLINK-10113.
  */
+@Internal
+@Deprecated
 public class AndCondition<T> extends IterativeCondition<T> {
 
 	private static final long serialVersionUID = -2471892317390197319L;
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/BooleanConditions.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/BooleanConditions.java
index aea5a3b..17c443f 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/BooleanConditions.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/BooleanConditions.java
@@ -18,10 +18,13 @@
 
 package org.apache.flink.cep.pattern.conditions;
 
+import org.apache.flink.annotation.Internal;
+
 /**
  * Utility class containing an {@link IterativeCondition} that always returns
  * {@code true} and one that always returns {@code false}.
  */
+@Internal
 public class BooleanConditions {
 
 	/**
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/NotCondition.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/NotCondition.java
index 9318c2f..72dc4bb 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/NotCondition.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/NotCondition.java
@@ -18,12 +18,18 @@
 
 package org.apache.flink.cep.pattern.conditions;
 
+import org.apache.flink.annotation.Internal;
+
 /**
  * A {@link IterativeCondition condition} which negates the condition it wraps
  * and returns {@code true} if the original condition returns {@code false}.
  *
  * @param <T> Type of the element to filter
+ * @deprecated Please use {@link RichNotCondition} instead. This class exists just for
+ * backwards compatibility and will be removed in FLINK-10113.
  */
+@Internal
+@Deprecated
 public class NotCondition<T> extends IterativeCondition<T> {
 	private static final long serialVersionUID = -2109562093871155005L;
 
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/OrCondition.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/OrCondition.java
index d3690ab..ac8c465 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/OrCondition.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/OrCondition.java
@@ -18,6 +18,7 @@
 
 package org.apache.flink.cep.pattern.conditions;
 
+import org.apache.flink.annotation.Internal;
 import org.apache.flink.util.Preconditions;
 
 /**
@@ -25,7 +26,11 @@ import org.apache.flink.util.Preconditions;
  * {@code OR} and returns {@code true} if at least one is {@code true}.
  *
  * @param <T> Type of the element to filter
+ * @deprecated Please use {@link RichOrCondition} instead. This class exists just for
+ * backwards compatibility and will be removed in FLINK-10113.
  */
+@Internal
+@Deprecated
 public class OrCondition<T> extends IterativeCondition<T> {
 
 	private static final long serialVersionUID = 2554610954278485106L;
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/AndCondition.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichAndCondition.java
similarity index 66%
copy from flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/AndCondition.java
copy to flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichAndCondition.java
index ac34c41..1d5d1e7 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/AndCondition.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichAndCondition.java
@@ -18,42 +18,39 @@
 
 package org.apache.flink.cep.pattern.conditions;
 
-import org.apache.flink.util.Preconditions;
+import org.apache.flink.annotation.Internal;
 
 /**
- * A {@link IterativeCondition condition} which combines two conditions with a logical
+ * A {@link RichIterativeCondition condition} which combines two conditions with a logical
  * {@code AND} and returns {@code true} if both are {@code true}.
  *
  * @param <T> Type of the element to filter
  */
-public class AndCondition<T> extends IterativeCondition<T> {
+@Internal
+public class RichAndCondition<T> extends RichCompositeIterativeCondition<T> {
 
-	private static final long serialVersionUID = -2471892317390197319L;
+	private static final long serialVersionUID = 1L;
 
-	private final IterativeCondition<T> left;
-	private final IterativeCondition<T> right;
-
-	public AndCondition(final IterativeCondition<T> left, final IterativeCondition<T> right) {
-		this.left = Preconditions.checkNotNull(left, "The condition cannot be null.");
-		this.right = Preconditions.checkNotNull(right, "The condition cannot be null.");
+	public RichAndCondition(final IterativeCondition<T> left, final IterativeCondition<T> right) {
+		super(left, right);
 	}
 
 	@Override
 	public boolean filter(T value, Context<T> ctx) throws Exception {
-		return left.filter(value, ctx) && right.filter(value, ctx);
+		return getLeft().filter(value, ctx) && getRight().filter(value, ctx);
 	}
 
 	/**
 	 * @return One of the {@link IterativeCondition conditions} combined in this condition.
 	 */
 	public IterativeCondition<T> getLeft() {
-		return left;
+		return getNestedConditions()[0];
 	}
 
 	/**
 	 * @return One of the {@link IterativeCondition conditions} combined in this condition.
 	 */
 	public IterativeCondition<T> getRight() {
-		return right;
+		return getNestedConditions()[1];
 	}
 }
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichCompositeIterativeCondition.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichCompositeIterativeCondition.java
new file mode 100644
index 0000000..5f7789a
--- /dev/null
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichCompositeIterativeCondition.java
@@ -0,0 +1,75 @@
+/*
+ * 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.flink.cep.pattern.conditions;
+
+import org.apache.flink.api.common.functions.RuntimeContext;
+import org.apache.flink.api.common.functions.util.FunctionUtils;
+import org.apache.flink.configuration.Configuration;
+import org.apache.flink.util.Preconditions;
+
+/**
+ * A base class of composite {@link IterativeCondition} conditions such as {@link RichAndCondition},
+ * {@link RichOrCondition} and {@link RichNotCondition}, etc. It handles the open, close and
+ * setRuntimeContext for the nested {@link IterativeCondition} conditions.
+ *
+ * @param <T> Type of the element to filter
+ */
+public abstract class RichCompositeIterativeCondition<T> extends RichIterativeCondition<T> {
+
+	private static final long serialVersionUID = 1L;
+
+	private final IterativeCondition<T>[] nestedConditions;
+
+	@SafeVarargs
+	public RichCompositeIterativeCondition(final IterativeCondition<T>... nestedConditions) {
+		for (IterativeCondition<T> condition : nestedConditions) {
+			Preconditions.checkNotNull(condition, "The condition cannot be null.");
+		}
+		this.nestedConditions = nestedConditions;
+	}
+
+	public IterativeCondition<T>[] getNestedConditions() {
+		return nestedConditions;
+	}
+
+	@Override
+	public void setRuntimeContext(RuntimeContext t) {
+		super.setRuntimeContext(t);
+
+		for (IterativeCondition<T> nestedCondition : nestedConditions) {
+			FunctionUtils.setFunctionRuntimeContext(nestedCondition, t);
+		}
+	}
+
+	@Override
+	public void open(Configuration parameters) throws Exception {
+		super.open(parameters);
+		for (IterativeCondition<T> nestedCondition : nestedConditions) {
+			FunctionUtils.openFunction(nestedCondition, parameters);
+		}
+	}
+
+	@Override
+	public void close() throws Exception {
+		super.close();
+		for (IterativeCondition<T> nestedCondition : nestedConditions) {
+			FunctionUtils.closeFunction(nestedCondition);
+		}
+	}
+}
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichIterativeCondition.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichIterativeCondition.java
new file mode 100644
index 0000000..12f017e
--- /dev/null
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichIterativeCondition.java
@@ -0,0 +1,81 @@
+/*
+ * 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.flink.cep.pattern.conditions;
+
+import org.apache.flink.api.common.functions.IterationRuntimeContext;
+import org.apache.flink.api.common.functions.RichFunction;
+import org.apache.flink.api.common.functions.RuntimeContext;
+import org.apache.flink.cep.CepRuntimeContext;
+import org.apache.flink.configuration.Configuration;
+import org.apache.flink.util.Preconditions;
+
+/**
+ * Rich variant of the {@link IterativeCondition}. As a {@link RichFunction}, it gives access to the
+ * {@link org.apache.flink.api.common.functions.RuntimeContext} and provides setup and teardown methods:
+ * {@link RichFunction#open(org.apache.flink.configuration.Configuration)} and
+ * {@link RichFunction#close()}.
+ */
+public abstract class RichIterativeCondition<T>
+		extends IterativeCondition<T>
+		implements RichFunction {
+
+	private static final long serialVersionUID = 1L;
+
+	// --------------------------------------------------------------------------------------------
+	//  Runtime context access
+	// --------------------------------------------------------------------------------------------
+
+	private transient RuntimeContext runtimeContext;
+
+	@Override
+	public void setRuntimeContext(RuntimeContext runtimeContext) {
+		Preconditions.checkNotNull(runtimeContext);
+
+		if (runtimeContext instanceof CepRuntimeContext) {
+			this.runtimeContext = runtimeContext;
+		} else {
+			this.runtimeContext = new CepRuntimeContext(runtimeContext);
+		}
+	}
+
+	@Override
+	public RuntimeContext getRuntimeContext() {
+		if (this.runtimeContext != null) {
+			return this.runtimeContext;
+		} else {
+			throw new IllegalStateException("The runtime context has not been initialized.");
+		}
+	}
+
+	@Override
+	public IterationRuntimeContext getIterationRuntimeContext() {
+		throw new UnsupportedOperationException("Not support to get the IterationRuntimeContext in IterativeCondition.");
+	}
+
+	// --------------------------------------------------------------------------------------------
+	//  Default life cycle methods
+	// --------------------------------------------------------------------------------------------
+
+	@Override
+	public void open(Configuration parameters) throws Exception {}
+
+	@Override
+	public void close() throws Exception {}
+
+}
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/NotCondition.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichNotCondition.java
similarity index 72%
copy from flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/NotCondition.java
copy to flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichNotCondition.java
index 9318c2f..a4929eb 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/NotCondition.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichNotCondition.java
@@ -18,23 +18,25 @@
 
 package org.apache.flink.cep.pattern.conditions;
 
+import org.apache.flink.annotation.Internal;
+
 /**
- * A {@link IterativeCondition condition} which negates the condition it wraps
+ * A {@link RichIterativeCondition condition} which negates the condition it wraps
  * and returns {@code true} if the original condition returns {@code false}.
  *
  * @param <T> Type of the element to filter
  */
-public class NotCondition<T> extends IterativeCondition<T> {
-	private static final long serialVersionUID = -2109562093871155005L;
+@Internal
+public class RichNotCondition<T> extends RichCompositeIterativeCondition<T> {
 
-	private final IterativeCondition<T> original;
+	private static final long serialVersionUID = 1L;
 
-	public NotCondition(final IterativeCondition<T> original) {
-		this.original = original;
+	public RichNotCondition(final IterativeCondition<T> original) {
+		super(original);
 	}
 
 	@Override
 	public boolean filter(T value, Context<T> ctx) throws Exception {
-		return original != null && !original.filter(value, ctx);
+		return !getNestedConditions()[0].filter(value, ctx);
 	}
 }
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/OrCondition.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichOrCondition.java
similarity index 66%
copy from flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/OrCondition.java
copy to flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichOrCondition.java
index d3690ab..03bd1e7 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/OrCondition.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/RichOrCondition.java
@@ -18,42 +18,39 @@
 
 package org.apache.flink.cep.pattern.conditions;
 
-import org.apache.flink.util.Preconditions;
+import org.apache.flink.annotation.Internal;
 
 /**
- * A {@link IterativeCondition condition} which combines two conditions with a logical
+ * A {@link RichIterativeCondition condition} which combines two conditions with a logical
  * {@code OR} and returns {@code true} if at least one is {@code true}.
  *
  * @param <T> Type of the element to filter
  */
-public class OrCondition<T> extends IterativeCondition<T> {
+@Internal
+public class RichOrCondition<T> extends RichCompositeIterativeCondition<T> {
 
-	private static final long serialVersionUID = 2554610954278485106L;
+	private static final long serialVersionUID = 1L;
 
-	private final IterativeCondition<T> left;
-	private final IterativeCondition<T> right;
-
-	public OrCondition(final IterativeCondition<T> left, final IterativeCondition<T> right) {
-		this.left = Preconditions.checkNotNull(left, "The condition cannot be null.");
-		this.right = Preconditions.checkNotNull(right, "The condition cannot be null.");
+	public RichOrCondition(final IterativeCondition<T> left, final IterativeCondition<T> right) {
+		super(left, right);
 	}
 
 	@Override
 	public boolean filter(T value, Context<T> ctx) throws Exception {
-		return left.filter(value, ctx) || right.filter(value, ctx);
+		return getLeft().filter(value, ctx) || getRight().filter(value, ctx);
 	}
 
 	/**
 	 * @return One of the {@link IterativeCondition conditions} combined in this condition.
 	 */
 	public IterativeCondition<T> getLeft() {
-		return left;
+		return getNestedConditions()[0];
 	}
 
 	/**
 	 * @return One of the {@link IterativeCondition conditions} combined in this condition.
 	 */
 	public IterativeCondition<T> getRight() {
-		return right;
+		return getNestedConditions()[1];
 	}
 }
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/SimpleCondition.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/SimpleCondition.java
index 9ca52c5..de46d1f 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/SimpleCondition.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/SimpleCondition.java
@@ -18,6 +18,7 @@
 
 package org.apache.flink.cep.pattern.conditions;
 
+import org.apache.flink.annotation.Internal;
 import org.apache.flink.api.common.functions.FilterFunction;
 
 /**
@@ -28,6 +29,7 @@ import org.apache.flink.api.common.functions.FilterFunction;
  * previously accepted elements in the pattern. Conditions that extend this class are simple {@code filter(...)}
  * functions that decide based on the properties of the element at hand.
  */
+@Internal
 public abstract class SimpleCondition<T> extends IterativeCondition<T> implements FilterFunction<T> {
 
 	private static final long serialVersionUID = 4942618239408140245L;
diff --git a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/SubtypeCondition.java b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/SubtypeCondition.java
index cff8693..249757d 100644
--- a/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/SubtypeCondition.java
+++ b/flink-libraries/flink-cep/src/main/java/org/apache/flink/cep/pattern/conditions/SubtypeCondition.java
@@ -18,6 +18,7 @@
 
 package org.apache.flink.cep.pattern.conditions;
 
+import org.apache.flink.annotation.Internal;
 import org.apache.flink.util.Preconditions;
 
 /**
@@ -26,6 +27,7 @@ import org.apache.flink.util.Preconditions;
  *
  * @param <T> Type of the elements to be filtered
  */
+@Internal
 public class SubtypeCondition<T> extends SimpleCondition<T> {
 	private static final long serialVersionUID = -2990017519957561355L;
 
diff --git a/flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/CEPITCase.java b/flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/CEPITCase.java
index e397d31..33c1fdd 100644
--- a/flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/CEPITCase.java
+++ b/flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/CEPITCase.java
@@ -19,13 +19,17 @@
 package org.apache.flink.cep;
 
 import org.apache.flink.api.common.functions.MapFunction;
+import org.apache.flink.api.common.state.MapStateDescriptor;
 import org.apache.flink.api.common.typeinfo.Types;
+import org.apache.flink.api.common.typeutils.base.LongSerializer;
 import org.apache.flink.api.java.functions.KeySelector;
 import org.apache.flink.api.java.tuple.Tuple2;
 import org.apache.flink.cep.nfa.NFA;
 import org.apache.flink.cep.nfa.aftermatch.AfterMatchSkipStrategy;
 import org.apache.flink.cep.pattern.Pattern;
+import org.apache.flink.cep.pattern.conditions.RichIterativeCondition;
 import org.apache.flink.cep.pattern.conditions.SimpleCondition;
+import org.apache.flink.configuration.Configuration;
 import org.apache.flink.streaming.api.TimeCharacteristic;
 import org.apache.flink.streaming.api.datastream.DataStream;
 import org.apache.flink.streaming.api.datastream.DataStreamUtils;
@@ -35,6 +39,7 @@ import org.apache.flink.streaming.api.watermark.Watermark;
 import org.apache.flink.streaming.api.windowing.time.Time;
 import org.apache.flink.test.util.AbstractTestBase;
 import org.apache.flink.types.Either;
+import org.apache.flink.util.Collector;
 
 import org.junit.Test;
 
@@ -716,4 +721,167 @@ public class CEPITCase extends AbstractTestBase {
 
 		assertEquals(expected, resultList);
 	}
+
+	@Test
+	public void testRichPatternFlatSelectFunction() throws Exception {
+		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
+
+		DataStream<Event> input = env.fromElements(
+			new Event(1, "barfoo", 1.0),
+			new Event(2, "start", 2.0),
+			new Event(3, "foobar", 3.0),
+			new SubEvent(4, "foo", 4.0, 1.0),
+			new Event(5, "middle", 5.0),
+			new SubEvent(6, "middle", 6.0, 2.0),
+			new SubEvent(7, "bar", 3.0, 3.0),
+			new Event(42, "42", 42.0),
+			new Event(8, "end", 1.0)
+		);
+
+		Pattern<Event, ?> pattern = Pattern.<Event>begin("start").where(new RichIterativeCondition<Event>() {
+
+			@Override
+			public boolean filter(Event value, Context<Event> ctx) throws Exception {
+				return value.getName().equals("start");
+			}
+		}).followedByAny("middle").subtype(SubEvent.class).where(
+			new SimpleCondition<SubEvent>() {
+
+				@Override
+				public boolean filter(SubEvent value) throws Exception {
+					return value.getName().equals("middle");
+				}
+			}
+		).followedByAny("end").where(new SimpleCondition<Event>() {
+
+			@Override
+			public boolean filter(Event value) throws Exception {
+				return value.getName().equals("end");
+			}
+		});
+
+		DataStream<String> result =
+			CEP.pattern(input, pattern).flatSelect(new RichPatternFlatSelectFunction<Event, String>() {
+
+				@Override
+				public void open(Configuration config) {
+					try {
+						getRuntimeContext().getMapState(new MapStateDescriptor<>(
+							"test",
+							LongSerializer.INSTANCE,
+							LongSerializer.INSTANCE));
+						throw new RuntimeException("Expected getMapState to fail with unsupported operation exception.");
+					} catch (UnsupportedOperationException e) {
+						// ignore, expected
+					}
+
+					getRuntimeContext().getUserCodeClassLoader();
+				}
+
+				@Override
+				public void flatSelect(Map<String, List<Event>> p, Collector<String> o) throws Exception {
+					StringBuilder builder = new StringBuilder();
+
+					builder.append(p.get("start").get(0).getId()).append(",")
+						.append(p.get("middle").get(0).getId()).append(",")
+						.append(p.get("end").get(0).getId());
+
+					o.collect(builder.toString());
+				}
+			}, Types.STRING);
+
+		List<String> resultList = new ArrayList<>();
+
+		DataStreamUtils.collect(result).forEachRemaining(resultList::add);
+
+		assertEquals(Arrays.asList("2,6,8"), resultList);
+	}
+
+	@Test
+	public void testRichPatternSelectFunction() throws Exception {
+		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
+		env.setParallelism(2);
+
+		DataStream<Event> input = env.fromElements(
+			new Event(1, "barfoo", 1.0),
+			new Event(2, "start", 2.0),
+			new Event(3, "start", 2.1),
+			new Event(3, "foobar", 3.0),
+			new SubEvent(4, "foo", 4.0, 1.0),
+			new SubEvent(3, "middle", 3.2, 1.0),
+			new Event(42, "start", 3.1),
+			new SubEvent(42, "middle", 3.3, 1.2),
+			new Event(5, "middle", 5.0),
+			new SubEvent(2, "middle", 6.0, 2.0),
+			new SubEvent(7, "bar", 3.0, 3.0),
+			new Event(42, "42", 42.0),
+			new Event(3, "end", 2.0),
+			new Event(2, "end", 1.0),
+			new Event(42, "end", 42.0)
+		).keyBy(new KeySelector<Event, Integer>() {
+
+			@Override
+			public Integer getKey(Event value) throws Exception {
+				return value.getId();
+			}
+		});
+
+		Pattern<Event, ?> pattern = Pattern.<Event>begin("start").where(new RichIterativeCondition<Event>() {
+
+			@Override
+			public boolean filter(Event value, Context<Event> ctx) throws Exception {
+				return value.getName().equals("start");
+			}
+		}).followedByAny("middle").subtype(SubEvent.class).where(
+			new SimpleCondition<SubEvent>() {
+
+				@Override
+				public boolean filter(SubEvent value) throws Exception {
+					return value.getName().equals("middle");
+				}
+			}
+		).followedByAny("end").where(new SimpleCondition<Event>() {
+
+				@Override
+				public boolean filter(Event value) throws Exception {
+					return value.getName().equals("end");
+				}
+			});
+
+		DataStream<String> result = CEP.pattern(input, pattern).select(new RichPatternSelectFunction<Event, String>() {
+			@Override
+			public void open(Configuration config) {
+				try {
+					getRuntimeContext().getMapState(new MapStateDescriptor<>(
+						"test",
+						LongSerializer.INSTANCE,
+						LongSerializer.INSTANCE));
+					throw new RuntimeException("Expected getMapState to fail with unsupported operation exception.");
+				} catch (UnsupportedOperationException e) {
+					// ignore, expected
+				}
+
+				getRuntimeContext().getUserCodeClassLoader();
+			}
+
+			@Override
+			public String select(Map<String, List<Event>> p) throws Exception {
+				StringBuilder builder = new StringBuilder();
+
+				builder.append(p.get("start").get(0).getId()).append(",")
+					.append(p.get("middle").get(0).getId()).append(",")
+					.append(p.get("end").get(0).getId());
+
+				return builder.toString();
+			}
+		});
+
+		List<String> resultList = new ArrayList<>();
+
+		DataStreamUtils.collect(result).forEachRemaining(resultList::add);
+
+		resultList.sort(String::compareTo);
+
+		assertEquals(Arrays.asList("2,2,2", "3,3,3", "42,42,42"), resultList);
+	}
 }
diff --git a/flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/CepRuntimeContextTest.java b/flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/CepRuntimeContextTest.java
new file mode 100644
index 0000000..6bc4081
--- /dev/null
+++ b/flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/CepRuntimeContextTest.java
@@ -0,0 +1,321 @@
+/*
+ * 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.flink.cep;
+
+import org.apache.flink.api.common.ExecutionConfig;
+import org.apache.flink.api.common.accumulators.Accumulator;
+import org.apache.flink.api.common.functions.AggregateFunction;
+import org.apache.flink.api.common.functions.BroadcastVariableInitializer;
+import org.apache.flink.api.common.functions.FoldFunction;
+import org.apache.flink.api.common.functions.ReduceFunction;
+import org.apache.flink.api.common.functions.RichFunction;
+import org.apache.flink.api.common.functions.RuntimeContext;
+import org.apache.flink.api.common.state.AggregatingStateDescriptor;
+import org.apache.flink.api.common.state.FoldingStateDescriptor;
+import org.apache.flink.api.common.state.ListStateDescriptor;
+import org.apache.flink.api.common.state.MapStateDescriptor;
+import org.apache.flink.api.common.state.ReducingStateDescriptor;
+import org.apache.flink.api.common.state.ValueStateDescriptor;
+import org.apache.flink.cep.pattern.conditions.RichAndCondition;
+import org.apache.flink.cep.pattern.conditions.RichCompositeIterativeCondition;
+import org.apache.flink.cep.pattern.conditions.RichIterativeCondition;
+import org.apache.flink.cep.pattern.conditions.RichNotCondition;
+import org.apache.flink.cep.pattern.conditions.RichOrCondition;
+import org.apache.flink.metrics.MetricGroup;
+import org.apache.flink.metrics.groups.UnregisteredMetricsGroup;
+import org.apache.flink.util.Collector;
+
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Test cases for {@link CepRuntimeContext}.
+ */
+public class CepRuntimeContextTest {
+
+	@Test
+	public void testRichCompositeIterativeCondition() throws Exception {
+		RichIterativeCondition<Integer> first = new TestRichIterativeCondition();
+		RichIterativeCondition<Integer> second = new TestRichIterativeCondition();
+		RichIterativeCondition<Integer> third = new TestRichIterativeCondition();
+
+		RichCompositeIterativeCondition function = new RichCompositeIterativeCondition(first, second, third) {
+			@Override
+			public boolean filter(Object value, Context ctx) throws Exception {
+				return false;
+			}
+		};
+		function.setRuntimeContext(mock(RuntimeContext.class));
+
+		assertTrue(first.getRuntimeContext() instanceof CepRuntimeContext);
+		assertTrue(second.getRuntimeContext() instanceof CepRuntimeContext);
+		assertTrue(third.getRuntimeContext() instanceof CepRuntimeContext);
+	}
+
+	@Test
+	public void testRichAndCondition() throws Exception {
+		RichIterativeCondition<Integer> left = new TestRichIterativeCondition();
+		RichIterativeCondition<Integer> right = new TestRichIterativeCondition();
+
+		RichAndCondition function = new RichAndCondition<>(left, right);
+		function.setRuntimeContext(mock(RuntimeContext.class));
+
+		assertTrue(left.getRuntimeContext() instanceof CepRuntimeContext);
+		assertTrue(right.getRuntimeContext() instanceof CepRuntimeContext);
+	}
+
+	@Test
+	public void testRichOrCondition() throws Exception {
+		RichIterativeCondition<Integer> left = new TestRichIterativeCondition();
+		RichIterativeCondition<Integer> right = new TestRichIterativeCondition();
+
+		RichOrCondition function = new RichOrCondition<>(left, right);
+		function.setRuntimeContext(mock(RuntimeContext.class));
+
+		assertTrue(left.getRuntimeContext() instanceof CepRuntimeContext);
+		assertTrue(right.getRuntimeContext() instanceof CepRuntimeContext);
+	}
+
+	@Test
+	public void testRichNotCondition() {
+		RichIterativeCondition<Integer> original = new TestRichIterativeCondition();
+
+		RichNotCondition function = new RichNotCondition<>(original);
+		function.setRuntimeContext(mock(RuntimeContext.class));
+
+		assertTrue(original.getRuntimeContext() instanceof CepRuntimeContext);
+	}
+
+	@Test
+	public void testRichPatternSelectFunction() {
+		verifyRuntimeContext(new TestRichPatternSelectFunction());
+	}
+
+	@Test
+	public void testRichPatternFlatSelectFunction() {
+		verifyRuntimeContext(new TestRichPatternFlatSelectFunction());
+	}
+
+	@Test
+	public void testRichIterativeCondition() {
+		verifyRuntimeContext(new TestRichIterativeCondition());
+	}
+
+	private void verifyRuntimeContext(final RichFunction function) {
+		final String taskName = "foobarTask";
+		final MetricGroup metricGroup = new UnregisteredMetricsGroup();
+		final int numberOfParallelSubtasks = 42;
+		final int indexOfSubtask = 43;
+		final int attemptNumber = 1337;
+		final String taskNameWithSubtask = "barfoo";
+		final ExecutionConfig executionConfig = mock(ExecutionConfig.class);
+		final ClassLoader userCodeClassLoader = mock(ClassLoader.class);
+
+		RuntimeContext mockedRuntimeContext = mock(RuntimeContext.class);
+
+		when(mockedRuntimeContext.getTaskName()).thenReturn(taskName);
+		when(mockedRuntimeContext.getMetricGroup()).thenReturn(metricGroup);
+		when(mockedRuntimeContext.getNumberOfParallelSubtasks()).thenReturn(numberOfParallelSubtasks);
+		when(mockedRuntimeContext.getIndexOfThisSubtask()).thenReturn(indexOfSubtask);
+		when(mockedRuntimeContext.getAttemptNumber()).thenReturn(attemptNumber);
+		when(mockedRuntimeContext.getTaskNameWithSubtasks()).thenReturn(taskNameWithSubtask);
+		when(mockedRuntimeContext.getExecutionConfig()).thenReturn(executionConfig);
+		when(mockedRuntimeContext.getUserCodeClassLoader()).thenReturn(userCodeClassLoader);
+
+		function.setRuntimeContext(mockedRuntimeContext);
+
+		RuntimeContext runtimeContext = function.getRuntimeContext();
+
+		assertTrue(runtimeContext instanceof CepRuntimeContext);
+		assertEquals(taskName, runtimeContext.getTaskName());
+		assertEquals(metricGroup, runtimeContext.getMetricGroup());
+		assertEquals(numberOfParallelSubtasks, runtimeContext.getNumberOfParallelSubtasks());
+		assertEquals(indexOfSubtask, runtimeContext.getIndexOfThisSubtask());
+		assertEquals(attemptNumber, runtimeContext.getAttemptNumber());
+		assertEquals(taskNameWithSubtask, runtimeContext.getTaskNameWithSubtasks());
+		assertEquals(executionConfig, runtimeContext.getExecutionConfig());
+		assertEquals(userCodeClassLoader, runtimeContext.getUserCodeClassLoader());
+
+		try {
+			runtimeContext.getDistributedCache();
+			fail("Expected getDistributedCached to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getState(new ValueStateDescriptor<>("foobar", Integer.class, 42));
+			fail("Expected getState to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getListState(new ListStateDescriptor<>("foobar", Integer.class));
+			fail("Expected getListState to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getReducingState(new ReducingStateDescriptor<>(
+				"foobar",
+				mock(ReduceFunction.class),
+				Integer.class));
+			fail("Expected getReducingState to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getAggregatingState(new AggregatingStateDescriptor<>(
+				"foobar",
+				mock(AggregateFunction.class),
+				Integer.class));
+			fail("Expected getAggregatingState to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getFoldingState(new FoldingStateDescriptor<>(
+				"foobar",
+				0,
+				mock(FoldFunction.class),
+				Integer.class));
+			fail("Expected getFoldingState to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getMapState(new MapStateDescriptor<>("foobar", Integer.class, String.class));
+			fail("Expected getMapState to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.addAccumulator("foobar", mock(Accumulator.class));
+			fail("Expected addAccumulator to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getAccumulator("foobar");
+			fail("Expected getAccumulator to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getAllAccumulators();
+			fail("Expected getAllAccumulators to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getIntCounter("foobar");
+			fail("Expected getIntCounter to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getLongCounter("foobar");
+			fail("Expected getLongCounter to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getDoubleCounter("foobar");
+			fail("Expected getDoubleCounter to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getHistogram("foobar");
+			fail("Expected getHistogram to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.hasBroadcastVariable("foobar");
+			fail("Expected hasBroadcastVariable to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getBroadcastVariable("foobar");
+			fail("Expected getBroadcastVariable to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+
+		try {
+			runtimeContext.getBroadcastVariableWithInitializer(
+				"foobar",
+				mock(BroadcastVariableInitializer.class));
+			fail("Expected getBroadcastVariableWithInitializer to fail with unsupported operation exception.");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+	}
+
+	private static class TestRichIterativeCondition extends RichIterativeCondition<Integer> {
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public boolean filter(Integer value, Context<Integer> ctx) throws Exception {
+			return false;
+		}
+	}
+
+	private static class TestRichPatternSelectFunction extends RichPatternSelectFunction<Integer, Integer> {
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public Integer select(Map<String, List<Integer>> pattern) throws Exception {
+			return null;
+		}
+	}
+
+	private static class TestRichPatternFlatSelectFunction extends RichPatternFlatSelectFunction<Integer, Integer> {
+		private static final long serialVersionUID = 1L;
+
+		@Override
+		public void flatSelect(Map<String, List<Integer>> pattern, Collector<Integer> out) throws Exception {
+			// no op
+		}
+	}
+}
diff --git a/flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/pattern/PatternTest.java b/flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/pattern/PatternTest.java
index 6d93ff3..7434252 100644
--- a/flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/pattern/PatternTest.java
+++ b/flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/pattern/PatternTest.java
@@ -21,7 +21,9 @@ package org.apache.flink.cep.pattern;
 import org.apache.flink.cep.Event;
 import org.apache.flink.cep.SubEvent;
 import org.apache.flink.cep.pattern.Quantifier.ConsumingStrategy;
-import org.apache.flink.cep.pattern.conditions.OrCondition;
+import org.apache.flink.cep.pattern.conditions.IterativeCondition;
+import org.apache.flink.cep.pattern.conditions.RichAndCondition;
+import org.apache.flink.cep.pattern.conditions.RichOrCondition;
 import org.apache.flink.cep.pattern.conditions.SimpleCondition;
 import org.apache.flink.cep.pattern.conditions.SubtypeCondition;
 import org.apache.flink.util.TestLogger;
@@ -33,6 +35,7 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
 
 /**
  * Tests for constructing {@link Pattern}.
@@ -102,7 +105,7 @@ public class PatternTest extends TestLogger {
 
 		assertNotNull(pattern.getCondition());
 		assertNotNull(previous.getCondition());
-		assertNull(previous2.getCondition());
+		assertNotNull(previous2.getCondition());
 
 		assertEquals(pattern.getName(), "end");
 		assertEquals(previous.getName(), "next");
@@ -187,14 +190,27 @@ public class PatternTest extends TestLogger {
 		assertNull(previous2.getPrevious());
 
 		assertEquals(ConsumingStrategy.SKIP_TILL_NEXT, pattern.getQuantifier().getConsumingStrategy());
-		assertFalse(previous.getCondition() instanceof OrCondition);
-		assertTrue(previous2.getCondition() instanceof OrCondition);
+		assertFalse(previous.getCondition() instanceof RichOrCondition);
+		assertTrue(previous2.getCondition() instanceof RichOrCondition);
 
 		assertEquals(pattern.getName(), "end");
 		assertEquals(previous.getName(), "or");
 		assertEquals(previous2.getName(), "start");
 	}
 
+	@Test
+	public void testRichCondition() {
+		Pattern<Event, Event> pattern =
+			Pattern.<Event>begin("start")
+				.where(mock(IterativeCondition.class))
+				.where(mock(IterativeCondition.class))
+			.followedBy("end")
+				.where(mock(IterativeCondition.class))
+				.or(mock(IterativeCondition.class));
+		assertTrue(pattern.getCondition() instanceof RichOrCondition);
+		assertTrue(pattern.getPrevious().getCondition() instanceof RichAndCondition);
+	}
+
 	@Test(expected = IllegalArgumentException.class)
 	public void testPatternTimesNegativeTimes() throws Exception {
 		Pattern.begin("start").where(dummyCondition()).times(-1);