private static void RunAssertionAllTypes( RegressionEnvironment env, string typeName, object[] events) { var graph = "@Name('flow') create dataflow MySelect\n" + "DefaultSupportSourceOp -> instream.with.dot<" + typeName + ">{}\n" + "filter(instream.with.dot) -> outstream.dot {filter: MyString = 'two'}\n" + "DefaultSupportCaptureOp(outstream.dot) {}"; env.CompileDeploy(graph); var source = new DefaultSupportSourceOp(events); var capture = new DefaultSupportCaptureOp(2, env.Container.LockManager()); var options = new EPDataFlowInstantiationOptions(); options.DataFlowInstanceUserObject = "myuserobject"; options.DataFlowInstanceId = "myinstanceId"; options.WithOperatorProvider(new DefaultSupportGraphOpProvider(source, capture)); var instance = env.Runtime.DataFlowService.Instantiate(env.DeploymentId("flow"), "MySelect", options); Assert.AreEqual("myuserobject", instance.UserObject); Assert.AreEqual("myinstanceId", instance.InstanceId); instance.Run(); var result = capture.GetAndReset()[0].ToArray(); Assert.AreEqual(1, result.Length); Assert.AreSame(events[1], result[0]); instance.Cancel(); env.UndeployAll(); }
public void TestTimeWindowTriggered() { _epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); String graph = "create dataflow MySelect\n" + "Emitter -> instream_s0<SupportBean>{name: 'emitterS0'}\n" + "Select(instream_s0) -> outstream {\n" + " select: (select sum(IntPrimitive) as sumInt from instream_s0.win:time(1 minute))\n" + "}\n" + "CaptureOp(outstream) {}\n"; _epService.EPRuntime.SendEvent(new CurrentTimeEvent(0)); _epService.EPAdministrator.CreateEPL(graph); DefaultSupportCaptureOp capture = new DefaultSupportCaptureOp(); IDictionary <String, Object> operators = CollectionUtil.PopulateNameValueMap("CaptureOp", capture); EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(operators)); EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options); EPDataFlowInstanceCaptive captive = instance.StartCaptive(); _epService.EPRuntime.SendEvent(new CurrentTimeEvent(5000)); captive.Emitters.Get("emitterS0").Submit(new SupportBean("E1", 2)); EPAssertionUtil.AssertProps(capture.GetCurrentAndReset()[0], "sumInt".Split(','), new Object[] { 2 }); _epService.EPRuntime.SendEvent(new CurrentTimeEvent(10000)); captive.Emitters.Get("emitterS0").Submit(new SupportBean("E2", 5)); EPAssertionUtil.AssertProps(capture.GetCurrentAndReset()[0], "sumInt".Split(','), new Object[] { 7 }); _epService.EPRuntime.SendEvent(new CurrentTimeEvent(65000)); EPAssertionUtil.AssertProps(capture.GetCurrentAndReset()[0], "sumInt".Split(','), new Object[] { 5 }); instance.Cancel(); }
public void RunAssertionJoinOrder(String fromClause) { String graph = "create dataflow MySelect\n" + "Emitter -> instream_s0<SupportBean_S0>{name: 'emitterS0'}\n" + "Emitter -> instream_s1<SupportBean_S1>{name: 'emitterS1'}\n" + "Emitter -> instream_s2<SupportBean_S2>{name: 'emitterS2'}\n" + "Select(instream_s0 as S0, instream_s1 as S1, instream_s2 as S2) -> outstream {\n" + " select: (select s0.id as s0id, s1.id as s1id, s2.id as s2id " + fromClause + ")\n" + "}\n" + "CaptureOp(outstream) {}\n"; EPStatement stmtGraph = _epService.EPAdministrator.CreateEPL(graph); DefaultSupportCaptureOp capture = new DefaultSupportCaptureOp(); IDictionary <String, Object> operators = CollectionUtil.PopulateNameValueMap("CaptureOp", capture); EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(operators)); EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options); EPDataFlowInstanceCaptive captive = instance.StartCaptive(); captive.Emitters.Get("emitterS0").Submit(new SupportBean_S0(1)); captive.Emitters.Get("emitterS1").Submit(new SupportBean_S1(10)); Assert.AreEqual(0, capture.GetCurrent().Length); captive.Emitters.Get("emitterS2").Submit(new SupportBean_S2(100)); Assert.AreEqual(1, capture.GetCurrent().Length); EPAssertionUtil.AssertProps(capture.GetCurrentAndReset()[0], "s0id,s1id,s2id".Split(','), new Object[] { 1, 10, 100 }); instance.Cancel(); captive.Emitters.Get("emitterS2").Submit(new SupportBean_S2(101)); Assert.AreEqual(0, capture.GetCurrent().Length); stmtGraph.Dispose(); }
public override void Run(EPServiceProvider epService) { epService.EPAdministrator.Configuration.AddImport(typeof(MyTokenizerCounter).Namespace); epService.EPAdministrator.Configuration.AddImport(typeof(DefaultSupportCaptureOp).Namespace); var epl = "create dataflow WordCount " + "MyLineFeedSource -> LineOfTextStream {} " + "MyTokenizerCounter(LineOfTextStream) -> SingleLineCountStream {}" + "MyWordCountAggregator(SingleLineCountStream) -> WordCountStream {}" + "DefaultSupportCaptureOp(WordCountStream) {}"; epService.EPAdministrator.CreateEPL(epl); var future = new DefaultSupportCaptureOp(1, SupportContainer.Instance.LockManager()); var source = new MyLineFeedSource(Collections.List("Test this code", "Test line two").GetEnumerator()); var options = new EPDataFlowInstantiationOptions() .OperatorProvider(new DefaultSupportGraphOpProvider(future, source)); epService.EPRuntime.DataFlowRuntime.Instantiate("WordCount", options).Start(); var received = future.GetValue(3, TimeUnit.SECONDS); Assert.AreEqual(1, received.Length); var stats = (MyWordCountStats)received[0]; EPAssertionUtil.AssertProps( epService.Container, stats, "Lines,Words,Chars".Split(','), new object[] { 2, 6, 23 }); }
private void RunAssertionSchemaObjectArray(EPServiceProvider epService) { epService.EPAdministrator.CreateEPL("create objectarray schema MyEventOA(p0 string, p1 long)"); RunAssertionOA(epService, false); RunAssertionOA(epService, true); // test collector epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " + "EventBusSource -> ReceivedStream<MyEventOA> {filter: p0 like 'A%'} " + "DefaultSupportCaptureOp(ReceivedStream) {}"); var collector = new MyCollector(); var future = new DefaultSupportCaptureOp(SupportContainer.Instance.LockManager()); var options = new EPDataFlowInstantiationOptions() .OperatorProvider(new DefaultSupportGraphOpProvider(future)) .ParameterProvider(new DefaultSupportGraphParamProvider( Collections.SingletonDataMap("collector", collector))); EPDataFlowInstance instance = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); instance.Start(); epService.EPRuntime.SendEvent(new object[] { "B", 100L }, "MyEventOA"); Thread.Sleep(50); Assert.IsNull(collector.Last); epService.EPRuntime.SendEvent(new object[] { "A", 101L }, "MyEventOA"); future.WaitForInvocation(100, 1); Assert.IsNotNull(collector.Last.Emitter); Assert.AreEqual("MyEventOA", collector.Last.Event.EventType.Name); Assert.AreEqual(false, collector.Last.IsSubmitEventBean); epService.EPAdministrator.DestroyAllStatements(); }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); env.CompileDeploy("create schema SomeType ()", path); env.CompileDeploy( "@Name('flow') create dataflow MyDataFlowOne " + "DefaultSupportSourceOp -> outstream<SomeType> {}" + "DefaultSupportCaptureOp(outstream) {}", path); var src = new DefaultSupportSourceOp(new object[] {new MyException("TestException")}); var output = new DefaultSupportCaptureOp(); var options = new EPDataFlowInstantiationOptions().WithOperatorProvider( new DefaultSupportGraphOpProvider(src, output)); var dfOne = env.Runtime.DataFlowService.Instantiate(env.DeploymentId("flow"), "MyDataFlowOne", options); try { dfOne.Run(); Assert.Fail(); } catch (EPDataFlowExecutionException ex) { Assert.IsTrue(ex.InnerException.InnerException is MyException); Assert.AreEqual( "Support-graph-source generated exception: TestException", ex.InnerException.Message); } Assert.AreEqual(EPDataFlowState.COMPLETE, dfOne.State); Assert.AreEqual(0, output.GetAndReset().Count); env.UndeployAll(); }
private void RunAssertionOA(bool underlying) { EPStatement stmtGraph = _epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " + "EventBusSource -> ReceivedStream<" + (underlying ? "MyEvent" : "EventBean<MyEvent>") + "> {} " + "DefaultSupportCaptureOp(ReceivedStream) {}"); DefaultSupportCaptureOp future = new DefaultSupportCaptureOp(1); EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions() .OperatorProvider(new DefaultSupportGraphOpProvider(future)); EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); instance.Start(); _epService.EPRuntime.SendEvent(new Object[] { "abc", 100L }, "MyEvent"); Object[] rows = future.GetValue(TimeSpan.FromSeconds(1)); Assert.AreEqual(1, rows.Length); if (underlying) { EPAssertionUtil.AssertEqualsExactOrder((Object[])rows[0], new Object[] { "abc", 100L }); } else { EPAssertionUtil.AssertProps((EventBean)rows[0], "p0,p1".Split(','), new Object[] { "abc", 100L }); } instance.Cancel(); stmtGraph.Dispose(); }
private void TryInvalidInstantiate( string dataflowName, string epl, string message) { var stmtGraph = CompileDeploy(runtime, epl).Statements[0]; var outputOp = new DefaultSupportCaptureOp(container.LockManager()); try { runtime.DataFlowService.Instantiate( stmtGraph.DeploymentId, dataflowName, new EPDataFlowInstantiationOptions().WithOperatorProvider(new DefaultSupportGraphOpProvider(outputOp))); Assert.Fail(); } catch (EPDataFlowInstantiationException ex) { Assert.AreEqual(message, ex.Message); } try { runtime.DeploymentService.UndeployAll(); } catch (EPUndeployException e) { throw new EPRuntimeException(e); } }
public void Run(RegressionEnvironment env) { if (env.IsHA) { return; } var graph = "@Name('flow') create dataflow MySelect\n" + "Emitter -> instream_s0<SupportEventWithLongArray>{name: 'emitterS0'}\n" + "Select(instream_s0) -> outstream {\n" + " select: (select window(Id) as ids from instream_s0#unique(Coll))\n" + "}\n" + "DefaultSupportCaptureOp(outstream) {}\n"; env.CompileDeploy(graph); var capture = new DefaultSupportCaptureOp(env.Container.LockManager()); var operators = CollectionUtil.PopulateNameValueMap("DefaultSupportCaptureOp", capture); var options = new EPDataFlowInstantiationOptions() .WithOperatorProvider(new DefaultSupportGraphOpProviderByOpName(operators)); var instance = env.Runtime.DataFlowService.Instantiate(env.DeploymentId("flow"), "MySelect", options); var captive = instance.StartCaptive(); AssertDataflowIds(captive, "E1", new long[] {1, 2}, capture, "E1"); AssertDataflowIds(captive, "E2", new long[] {1, 2}, capture, "E2"); AssertDataflowIds(captive, "E3", new long[] {1}, capture, "E2,E3"); AssertDataflowIds(captive, "E4", new long[] {1}, capture, "E2,E4"); AssertDataflowIds(captive, "E5", new long[] {1, 2}, capture, "E4,E5"); instance.Cancel(); env.UndeployAll(); }
private void RunAssertionFastCompleteNonBlocking(EPServiceProvider epService) { // declare epService.EPAdministrator.CreateEPL( "create dataflow MyDataFlowOne " + "BeaconSource -> BeaconStream {iterations : 1}" + "DefaultSupportCaptureOp(BeaconStream) {}"); // instantiate var future = new DefaultSupportCaptureOp(1, SupportContainer.Instance.LockManager()); var options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProvider(future)); var dfOne = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); Assert.AreEqual("MyDataFlowOne", dfOne.DataFlowName); Assert.AreEqual(EPDataFlowState.INSTANTIATED, dfOne.State); Assert.IsFalse(future.IsDone()); // non-blocking run, spinning wait dfOne.Start(); var start = PerformanceObserver.MilliTime; while (dfOne.State != EPDataFlowState.COMPLETE) { if (PerformanceObserver.MilliTime - start > 1000) { Assert.Fail(); } } Assert.AreEqual(1, future.GetValue(TimeSpan.Zero).Length); // assert past-exec TryAssertionAfterExec(dfOne); epService.EPAdministrator.DestroyAllStatements(); }
private void RunAssertionStatementNameExists(EPServiceProvider epService, string typeName, object[] events) { epService.EPAdministrator.CreateEPL("@Name('MyStatement') select * from " + typeName); epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " + "create schema AllObject System.Object," + "EPStatementSource -> thedata<AllObject> {" + " statementName : 'MyStatement'," + "} " + "DefaultSupportCaptureOp(thedata) {}"); var captureOp = new DefaultSupportCaptureOp(2, SupportContainer.Instance.LockManager()); var options = new EPDataFlowInstantiationOptions() .OperatorProvider(new DefaultSupportGraphOpProvider(captureOp)); EPDataFlowInstance df = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); df.Start(); EventSender sender = epService.EPRuntime.GetEventSender(typeName); foreach (Object @event in events) { sender.SendEvent(@event); } captureOp.GetValue(1, TimeUnit.SECONDS); EPAssertionUtil.AssertEqualsExactOrder(events, captureOp.Current); df.Cancel(); epService.EPAdministrator.DestroyAllStatements(); }
private void RunAssertionFastCompleteBlocking(EPServiceProvider epService) { // declare epService.EPAdministrator.CreateEPL( "create dataflow MyDataFlowOne " + "BeaconSource -> BeaconStream {iterations : 1}" + "DefaultSupportCaptureOp(BeaconStream) {}"); // instantiate var future = new DefaultSupportCaptureOp(1, SupportContainer.Instance.LockManager()); var options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProvider(future)); var dfOne = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); Assert.AreEqual("MyDataFlowOne", dfOne.DataFlowName); Assert.AreEqual(EPDataFlowState.INSTANTIATED, dfOne.State); // has not run Thread.Sleep(1000); Assert.IsFalse(future.IsDone()); // blocking run dfOne.Run(); Assert.AreEqual(EPDataFlowState.COMPLETE, dfOne.State); Assert.AreEqual(1, future.GetValue(TimeSpan.Zero).Length); // assert past-exec TryAssertionAfterExec(dfOne); epService.EPAdministrator.DestroyAllStatements(); }
private void RunAssertionNonBlockingJoinSingleRunnable(EPServiceProvider epService) { // declare epService.EPAdministrator.CreateEPL("create schema SomeType ()"); epService.EPAdministrator.CreateEPL( "create dataflow MyDataFlowOne " + "DefaultSupportSourceOp -> outstream<SomeType> {}" + "DefaultSupportCaptureOp(outstream) {}"); // instantiate var latch = new CountDownLatch(1); var source = new DefaultSupportSourceOp(new object[] {latch, new object[] {1}}); var future = new DefaultSupportCaptureOp(1, SupportContainer.Instance.LockManager()); var options = new EPDataFlowInstantiationOptions().OperatorProvider( new DefaultSupportGraphOpProvider(source, future)); var dfOne = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); Assert.AreEqual("MyDataFlowOne", dfOne.DataFlowName); Assert.AreEqual(EPDataFlowState.INSTANTIATED, dfOne.State); dfOne.Start(); Thread.Sleep(100); Assert.AreEqual(EPDataFlowState.RUNNING, dfOne.State); latch.CountDown(); dfOne.Join(); Assert.AreEqual(EPDataFlowState.COMPLETE, dfOne.State); Assert.AreEqual(1, future.GetAndReset()[0].Count); Assert.AreEqual(2, source.GetCurrentCount()); dfOne.Cancel(); Assert.AreEqual(EPDataFlowState.COMPLETE, dfOne.State); epService.EPAdministrator.DestroyAllStatements(); }
private void RunAssertionNonBlockingCancel(EPServiceProvider epService) { // declare epService.EPAdministrator.CreateEPL("create schema SomeType ()"); epService.EPAdministrator.CreateEPL( "create dataflow MyDataFlowOne " + "SourceOne -> outstream<SomeType> {}" + "OutputOp(outstream) {}"); // instantiate var latchOne = new CountDownLatch(1); var ops = new Dictionary<string, object>(); ops.Put("SourceOne", new DefaultSupportSourceOp(new object[] {latchOne, new object[] {1}})); var output = new DefaultSupportCaptureOp(SupportContainer.Instance.LockManager()); ops.Put("OutputOp", output); var options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(ops)); var dfOne = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); dfOne.Start(); Assert.AreEqual(EPDataFlowState.RUNNING, dfOne.State); dfOne.Cancel(); latchOne.CountDown(); Thread.Sleep(100); Assert.AreEqual(EPDataFlowState.CANCELLED, dfOne.State); Assert.AreEqual(0, output.GetAndReset().Count); epService.EPAdministrator.DestroyAllStatements(); }
public void TestFactorial() { _epService.EPAdministrator.Configuration.AddImport(typeof(MyFactorialOp).FullName); _epService.EPAdministrator.Configuration.AddImport(typeof(DefaultSupportCaptureOp)); String epl = "create dataflow FactorialGraph \n" + "" + "create objectarray schema InputSchema (number int),\n" + "create objectarray schema TempSchema (current int, temp long),\n" + "create objectarray schema FinalSchema (result long),\n" + "\n" + "BeaconSource -> InputData<InputSchema> {number:5, iterations:1}\n" + "\n" + "MyFactorialOp(InputData as Input, TempResult as Temp) -> TempResult<TempSchema>, FinalResult<FinalSchema>{}\n" + "\n" + "DefaultSupportCaptureOp(FinalResult) {}\n"; _epService.EPAdministrator.CreateEPL(epl); var future = new DefaultSupportCaptureOp(1); var options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProvider(future)); _epService.EPRuntime.DataFlowRuntime.Instantiate("FactorialGraph", options).Start(); Object[] result = future.GetValue(TimeSpan.FromSeconds(3)); Assert.AreEqual(1, result.Length); Assert.AreEqual((long)5 * 4 * 3 * 2, ((Object[])result[0])[0]); }
public void TestBlockingException() { _epService.EPAdministrator.CreateEPL( "create dataflow MyDataFlowOne " + "DefaultSupportSourceOp -> outstream<SomeType> {}" + "DefaultSupportCaptureOp(outstream) {}"); var src = new DefaultSupportSourceOp( new Object[] { new MyRuntimeException("TestException") }); var output = new DefaultSupportCaptureOp(); var options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProvider(src, output)); var dfOne = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); try { dfOne.Run(); Assert.Fail(); } catch (EPDataFlowExecutionException ex) { Assert.IsTrue(ex.InnerException.InnerException is MyRuntimeException); Assert.AreEqual("Support-graph-source generated exception: TestException", ex.InnerException.Message); } Assert.AreEqual(EPDataFlowState.COMPLETE, dfOne.State); Assert.AreEqual(0, output.GetAndReset().Count); }
public void Run(RegressionEnvironment env) { var epl = "@Name('flow') create dataflow FactorialGraph \n" + "" + "create objectarray schema InputSchema (number int),\n" + "create objectarray schema TempSchema (current int, temp long),\n" + "create objectarray schema FinalSchema (result long),\n" + "\n" + "BeaconSource -> InputData<InputSchema> {number:5, iterations:1}\n" + "\n" + "MyFactorialOp(InputData as Input, TempResult as Temp) -> TempResult<TempSchema>, FinalResult<FinalSchema>{}\n" + "\n" + "DefaultSupportCaptureOp(FinalResult) {}\n"; env.CompileDeploy(epl); var future = new DefaultSupportCaptureOp(1, env.Container.LockManager()); var options = new EPDataFlowInstantiationOptions() .WithOperatorProvider(new DefaultSupportGraphOpProvider(future)); env.Runtime.DataFlowService.Instantiate(env.DeploymentId("flow"), "FactorialGraph", options).Start(); object[] result; try { result = future.GetValue(3, TimeUnit.SECONDS); } catch (Exception t) { throw new EPException(t); } Assert.AreEqual(1, result.Length); Assert.AreEqual((long) 5 * 4 * 3 * 2, ((object[]) result[0])[0]); env.UndeployAll(); }
public void TestBlockingMultipleRunnable() { // declare _epService.EPAdministrator.CreateEPL( "create dataflow MyDataFlowOne " + "SourceOne -> outstream<SomeType> {}" + "SourceTwo -> outstream<SomeType> {}" + "Future(outstream) {}"); // instantiate var latchOne = new CountDownLatch(1); var latchTwo = new CountDownLatch(1); IDictionary <String, Object> ops = new Dictionary <String, Object>(); ops.Put( "SourceOne", new DefaultSupportSourceOp( new Object[] { latchOne, new Object[] { 1 } })); ops.Put( "SourceTwo", new DefaultSupportSourceOp( new Object[] { latchTwo, new Object[] { 1 } })); var future = new DefaultSupportCaptureOp(2); ops["Future"] = future; EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(ops)); EPDataFlowInstance dfOne = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); try { dfOne.Run(); Assert.Fail(); } catch (UnsupportedOperationException ex) { Assert.AreEqual( "The data flow 'MyDataFlowOne' has zero or multiple sources and requires the use of the start method instead", ex.Message); } latchTwo.CountDown(); dfOne.Start(); latchOne.CountDown(); dfOne.Join(); Assert.AreEqual(EPDataFlowState.COMPLETE, dfOne.State); Assert.AreEqual(2, future.GetAndReset().Count); }
public void TestSchemaObjectArray() { _epService.EPAdministrator.CreateEPL("create objectarray schema MyEvent(p0 string, p1 long)"); RunAssertionOA(false); RunAssertionOA(true); // test collector _epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " + "EventBusSource -> ReceivedStream<MyEvent> {filter: p0 like 'A%'} " + "DefaultSupportCaptureOp(ReceivedStream) {}"); MyCollector collector = new MyCollector(); DefaultSupportCaptureOp future = new DefaultSupportCaptureOp(); EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions() .OperatorProvider(new DefaultSupportGraphOpProvider(future)) .ParameterProvider(new DefaultSupportGraphParamProvider(Collections.SingletonDataMap("collector", collector))); EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); instance.Start(); _epService.EPRuntime.SendEvent(new Object[] { "B", 100L }, "MyEvent"); Thread.Sleep(50); Assert.IsNull(collector.GetLast()); _epService.EPRuntime.SendEvent(new Object[] { "A", 101L }, "MyEvent"); future.WaitForInvocation(100, 1); Assert.NotNull(collector.GetLast().Emitter); Assert.AreEqual("MyEvent", collector.GetLast().Event.EventType.Name); Assert.AreEqual(false, collector.GetLast().IsSubmitEventBean); }
public void TestFastCompleteBlocking() { // declare _epService.EPAdministrator.CreateEPL( "create dataflow MyDataFlowOne " + "BeaconSource -> BeaconStream {iterations : 1}" + "DefaultSupportCaptureOp(BeaconStream) {}"); // instantiate var future = new DefaultSupportCaptureOp(1); EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProvider(future)); EPDataFlowInstance dfOne = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); Assert.AreEqual("MyDataFlowOne", dfOne.DataFlowName); Assert.AreEqual(EPDataFlowState.INSTANTIATED, dfOne.State); // has not run Thread.Sleep(1000); Assert.IsFalse(future.IsDone()); // blocking run dfOne.Run(); Assert.AreEqual(EPDataFlowState.COMPLETE, dfOne.State); Assert.AreEqual(1, future.GetValue(TimeSpan.MaxValue).Length); // assert past-exec RunAssertionAfterExec(dfOne); }
private void RunAssertionStatementNameExists(String typeName, Object[] events) { _epService.EPAdministrator.CreateEPL("@Name('MyStatement') select * from " + typeName); _epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " + "create schema AllObject System.Object," + "EPStatementSource -> thedata<AllObject> {" + " statementName : 'MyStatement'," + "} " + "DefaultSupportCaptureOp(thedata) {}"); var captureOp = new DefaultSupportCaptureOp(2); var options = new EPDataFlowInstantiationOptions() .OperatorProvider(new DefaultSupportGraphOpProvider(captureOp)); var df = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); df.Start(); var sender = _epService.EPRuntime.GetEventSender(typeName); foreach (var theEvent in events) { sender.SendEvent(theEvent); } captureOp.GetValue(TimeSpan.FromSeconds(1)); EPAssertionUtil.AssertEqualsExactOrder(events, captureOp.GetCurrent()); df.Cancel(); _epService.EPAdministrator.DestroyAllStatements(); }
public void TestFastCompleteNonBlocking() { // declare _epService.EPAdministrator.CreateEPL( "create dataflow MyDataFlowOne " + "BeaconSource -> BeaconStream {iterations : 1}" + "DefaultSupportCaptureOp(BeaconStream) {}"); // instantiate var future = new DefaultSupportCaptureOp(1); EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProvider(future)); EPDataFlowInstance dfOne = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); Assert.AreEqual("MyDataFlowOne", dfOne.DataFlowName); Assert.AreEqual(EPDataFlowState.INSTANTIATED, dfOne.State); Assert.IsFalse(future.IsDone()); // non-blocking run, spinning wait dfOne.Start(); long start = Environment.TickCount; while (dfOne.State != EPDataFlowState.COMPLETE) { if (Environment.TickCount - start > 1000) { Assert.Fail(); } } Assert.AreEqual(1, future.GetValue(TimeSpan.MaxValue).Length); // assert past-exec RunAssertionAfterExec(dfOne); }
private void RunAssertionAllTypes(String typeName, Object[] events) { String graph = "create dataflow MySelect\n" + "DefaultSupportSourceOp -> instream.with.dot<" + typeName + ">{}\n" + "Filter(instream.with.dot) -> outstream.dot {filter: myString = 'two'}\n" + "DefaultSupportCaptureOp(outstream.dot) {}"; EPStatement stmtGraph = _epService.EPAdministrator.CreateEPL(graph); DefaultSupportSourceOp source = new DefaultSupportSourceOp(events); DefaultSupportCaptureOp capture = new DefaultSupportCaptureOp(2); EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions(); options.SetDataFlowInstanceUserObject("myuserobject"); options.SetDataFlowInstanceId("myinstanceid"); options.OperatorProvider(new DefaultSupportGraphOpProvider(source, capture)); EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options); Assert.AreEqual("myuserobject", instance.UserObject); Assert.AreEqual("myinstanceid", instance.InstanceId); instance.Run(); Object[] result = capture.GetAndReset()[0].ToArray(); Assert.AreEqual(1, result.Length); Assert.AreSame(events[1], result[0]); instance.Cancel(); stmtGraph.Dispose(); }
public void Run(RegressionEnvironment env) { var epl = "@Name('flow') create dataflow WordCount " + "MyLineFeedSource -> LineOfTextStream {} " + "MyTokenizerCounter(LineOfTextStream) -> SingleLineCountStream {}" + "MyWordCountAggregator(SingleLineCountStream) -> WordCountStream {}" + "DefaultSupportCaptureOp(WordCountStream) {}"; env.CompileDeploy(epl); var future = new DefaultSupportCaptureOp(1, env.Container.LockManager()); var source = new MyLineFeedSource(Arrays.AsList("Test this code", "Test line two").GetEnumerator()); var options = new EPDataFlowInstantiationOptions() .WithOperatorProvider(new DefaultSupportGraphOpProvider(future, source)); env.Runtime.DataFlowService.Instantiate(env.DeploymentId("flow"), "WordCount", options).Start(); var received = new object[0]; try { received = future.GetValue(3, TimeUnit.SECONDS); } catch (Exception t) { throw new EPException(t); } Assert.AreEqual(1, received.Length); var stats = (MyWordCountStats) received[0]; Assert.AreEqual(2, stats.Lines); Assert.AreEqual(6, stats.Words); Assert.AreEqual(23, stats.Chars); env.UndeployAll(); }
private void RunAssertionOA(EPServiceProvider epService, bool underlying) { EPStatement stmtGraph = epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " + "EventBusSource -> ReceivedStream<" + (underlying ? "MyEventOA" : "EventBean<MyEventOA>") + "> {} " + "DefaultSupportCaptureOp(ReceivedStream) {}"); var future = new DefaultSupportCaptureOp(1, SupportContainer.Instance.LockManager()); var options = new EPDataFlowInstantiationOptions() .OperatorProvider(new DefaultSupportGraphOpProvider(future)); EPDataFlowInstance instance = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); instance.Start(); epService.EPRuntime.SendEvent(new object[] { "abc", 100L }, "MyEventOA"); object[] rows = future.GetValue(1, TimeUnit.SECONDS); Assert.AreEqual(1, rows.Length); if (underlying) { EPAssertionUtil.AssertEqualsExactOrder((object[])rows[0], new object[] { "abc", 100L }); } else { EPAssertionUtil.AssertProps((EventBean)rows[0], "p0,p1".Split(','), new object[] { "abc", 100L }); } instance.Cancel(); stmtGraph.Dispose(); }
private static void RunAssertion(RegressionEnvironment env) { var future = new DefaultSupportCaptureOp(1, env.Container.LockManager()); var source = new MyObjectArrayGraphSource( Arrays.AsList( new object[] {"trade", "GE", 100d, 1000L, null, null}, // vwap = 100, minPrice=100 new object[] {"quote", "GE", null, null, 99.5d, 2000L} // ) .GetEnumerator()); var options = new EPDataFlowInstantiationOptions() .WithOperatorProvider(new DefaultSupportGraphOpProvider(future, source)); env.Runtime.DataFlowService.Instantiate(env.DeploymentId("flow"), "VWAPSample", options).Start(); object[] received; try { received = future.GetValue(5, TimeUnit.SECONDS); } catch (Exception t) { throw new EPException(t); } Assert.AreEqual(1, received.Length); var receivedArray = received[0].UnwrapIntoArray<object>(); EPAssertionUtil.AssertProps( env.Container, receivedArray, new string[] { "index" }, new object[] { 2000 * Math.Exp(100 - 99.5) }); env.UndeployAll(); }
public void TestOuterJoinMultirow() { _epService.EPAdministrator.Configuration.AddEventType(typeof(SupportBean_S0)); _epService.EPAdministrator.Configuration.AddEventType(typeof(SupportBean_S1)); String graph = "create dataflow MySelect\n" + "Emitter -> instream_s0<SupportBean_S0>{name: 'emitterS0'}\n" + "Emitter -> instream_s1<SupportBean_S1>{name: 'emitterS1'}\n" + "Select(instream_s0 as S0, instream_s1 as S1) -> outstream {\n" + " select: (select p00, p10 from S0.win:keepall() full outer join S1.win:keepall())\n" + "}\n" + "CaptureOp(outstream) {}\n"; _epService.EPAdministrator.CreateEPL(graph); DefaultSupportCaptureOp capture = new DefaultSupportCaptureOp(); IDictionary <String, Object> operators = CollectionUtil.PopulateNameValueMap("CaptureOp", capture); EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProviderByOpName(operators)); EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MySelect", options); EPDataFlowInstanceCaptive captive = instance.StartCaptive(); captive.Emitters.Get("emitterS0").Submit(new SupportBean_S0(1, "S0_1")); EPAssertionUtil.AssertProps(capture.GetCurrentAndReset()[0], "p00,p11".Split(','), new Object[] { "S0_1", null }); instance.Cancel(); }
private void RunAssertionMapType(EPServiceProvider epService) { epService.EPAdministrator.Configuration.AddImport(typeof(SupportBean)); epService.EPAdministrator.CreateEPL("create map schema MyMap (p0 string, p1 int)"); epService.EPAdministrator.CreateEPL( "create dataflow MyDataFlowOne " + "DefaultSupportSourceOp -> outstream<MyMap> {}" + "MyMapOutputOp(outstream) {}" + "DefaultSupportCaptureOp(outstream) {}"); var source = new DefaultSupportSourceOp(new object[] {MakeMap("E1", 1)}); var outputOne = new MyMapOutputOp(); var outputTwo = new DefaultSupportCaptureOp(SupportContainer.Instance.LockManager()); var options = new EPDataFlowInstantiationOptions().OperatorProvider( new DefaultSupportGraphOpProvider(source, outputOne, outputTwo)); var dfOne = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); dfOne.Run(); EPAssertionUtil.AssertPropsPerRow( outputOne.GetAndReset().ToArray(), "p0,p1".Split(','), new[] {new object[] {"E1", 1}}); EPAssertionUtil.AssertPropsPerRow( epService.Container, outputTwo.GetAndReset()[0].ToArray(), "p0,p1".Split(','), new[] {new object[] {"E1", 1}}); epService.EPAdministrator.DestroyAllStatements(); }
private void RunAssertionFactorial(EPServiceProvider epService) { epService.EPAdministrator.Configuration.AddImport(typeof(MyFactorialOp)); string epl = "create dataflow FactorialGraph \n" + "" + "create objectarray schema InputSchema (number int),\n" + "create objectarray schema TempSchema (current int, temp long),\n" + "create objectarray schema FinalSchema (result long),\n" + "\n" + "BeaconSource -> InputData<InputSchema> {number:5, iterations:1}\n" + "\n" + "MyFactorialOp(InputData as Input, TempResult as Temp) -> TempResult<TempSchema>, FinalResult<FinalSchema>{}\n" + "\n" + "DefaultSupportCaptureOp(FinalResult) {}\n"; epService.EPAdministrator.CreateEPL(epl); var future = new DefaultSupportCaptureOp(1, SupportContainer.Instance.LockManager()); var options = new EPDataFlowInstantiationOptions() .OperatorProvider(new DefaultSupportGraphOpProvider(future)); epService.EPRuntime.DataFlowRuntime.Instantiate("FactorialGraph", options).Start(); object[] result = future.GetValue(3, TimeUnit.SECONDS); Assert.AreEqual(1, result.Length); Assert.AreEqual((long)5 * 4 * 3 * 2, ((object[])result[0])[0]); epService.EPAdministrator.DestroyAllStatements(); }
private static void RunAssertionAllTypes( RegressionEnvironment env, string typeName, object[] events) { var graph = "@Name('flow') create dataflow MySelect\n" + "DefaultSupportSourceOp -> instream<" + typeName + ">{}\n" + "select(instream as ME) -> outstream {select: (select MyString, sum(MyInt) as total from ME)}\n" + "DefaultSupportCaptureOp(outstream) {}"; env.CompileDeploy(graph); var source = new DefaultSupportSourceOp(events); var capture = new DefaultSupportCaptureOp(2, env.Container.LockManager()); var options = new EPDataFlowInstantiationOptions(); options.WithOperatorProvider(new DefaultSupportGraphOpProvider(source, capture)); var instance = env.Runtime.DataFlowService.Instantiate(env.DeploymentId("flow"), "MySelect", options); instance.Run(); var result = capture.GetAndReset()[0].UnwrapIntoArray<object>(); EPAssertionUtil.AssertPropsPerRow( env.Container, result, new[] { "MyString","total" }, new[] { new object[] {"one", 1}, new object[] {"two", 3} }); instance.Cancel(); env.UndeployAll(); }