public StmtMgmtCallablePair( string epl, EPCompiled compiled) { Epl = epl; Compiled = compiled; }
public RegressionEnvironment Deploy( EPCompiled compiled, DeploymentOptions options) { Runtime.DeploymentService.Deploy(compiled, options); return this; }
public static ModuleProviderCLPair Analyze( EPCompiled compiled, ClassLoader classLoaderParent, PathRegistry <String, ClassProvided> classProvidedPathRegistry) { var classLoader = new PriorityClassLoader(classLoaderParent, compiled.Assemblies); var resourceClassName = compiled.Manifest.ModuleProviderClassName; // load module resource class Type clazz; try { clazz = classLoader.GetClass(resourceClassName); } catch (Exception e) { throw new EPException(e); } // instantiate ModuleProvider moduleResource; try { moduleResource = (ModuleProvider)TypeHelper.Instantiate(clazz); } catch (EPException) { throw; } catch (Exception e) { throw new EPException(e); } return(new ModuleProviderCLPair(classLoader, moduleResource)); }
private static DeploymentInternal Deploy( bool recovery, string deploymentId, int statementIdFirstStatement, EPCompiled compiled, StatementNameRuntimeOption statementNameResolverRuntime, StatementUserObjectRuntimeOption userObjectResolverRuntime, StatementSubstitutionParameterOption substitutionParameterResolver, DeploymentClassLoaderOption deploymentClassLoaderOption, EPRuntimeSPI epRuntime) { // set variable local version epRuntime.ServicesContext.VariableManagementService.SetLocalVersion(); try { return(DeploySafe( recovery, deploymentId, statementIdFirstStatement, compiled, statementNameResolverRuntime, userObjectResolverRuntime, substitutionParameterResolver, deploymentClassLoaderOption, epRuntime)); } catch (EPDeployException) { throw; } catch (Exception ex) { throw new EPDeployException(ex.Message, ex, -1); } }
public void Run(RegressionEnvironment env) { SetupInfra(env, namedWindow); EPCompiled insertA = CompileRuntimePath(env, "A", "insert into MyInfra(c0, c1) values ('A1', 10)"); EPCompiled insertB = CompileRuntimePath(env, "B", "insert into MyInfra(c2, c3) values (20, 'B1')"); env.Runtime.FireAndForgetService.ExecuteQuery(insertA); env.Runtime.FireAndForgetService.ExecuteQuery(insertB); EPCompiled selectA = CompileRuntimePath(env, "A", "select * from MyInfra"); EPCompiled selectB = CompileRuntimePath(env, "B", "select * from MyInfra"); EPFireAndForgetQueryResult resultA = env.Runtime.FireAndForgetService.ExecuteQuery(selectA); EPAssertionUtil.AssertPropsPerRow(resultA.GetEnumerator(), "c0,c1".SplitCsv(), new object[][] { new object[] { "A1", 10 } }); EPFireAndForgetQueryResult resultB = env.Runtime.FireAndForgetService.ExecuteQuery(selectB); EPAssertionUtil.AssertPropsPerRow(resultB.GetEnumerator(), "c2,c3".SplitCsv(), new object[][] { new object[] { 20, "B1" } }); env.UndeployAll(); }
/// <summary> /// Ctor. /// </summary> /// <param name="compiled">compiled module to deploy</param> /// <param name="options">deployment options</param> public EPDeploymentRolloutCompiled( EPCompiled compiled, DeploymentOptions options) { Compiled = compiled; Options = options ?? new DeploymentOptions(); }
public void Run(RegressionEnvironment env) { SupportUpdateListener listener = new SupportUpdateListener(); for (int i = 0; i < 100; i++) { string epl = "@Name('s" + i + "') select * from SupportBean(TheString = '" + i + "' or IntPrimitive=" + i + ")"; EPCompiled compiled = env.Compile(epl); env.Deploy(compiled).Statement("s" + i).AddListener(listener); } var delta = PerformanceObserver.TimeMillis( () => { // System.out.println("Starting " + DateTime.print(new Date())); for (int i = 0; i < 10000; i++) { env.SendEventBean(new SupportBean("100", 1)); Assert.IsTrue(listener.IsInvoked); listener.Reset(); } }); #if DEBUG Assert.That(delta, Is.LessThan(1500)); #else Assert.That(delta, Is.LessThan(500)); #endif env.UndeployAll(); }
public void Run(RegressionEnvironment env) { #if false var resourceManager = env.Container.ResourceManager(); var resourceName = "regression/epcompiled_version_8.0.0.epl_dll_for_deployment"; string file = FileUtil.FindClasspathFile(resourceName); if (file == null) { throw new EPRuntimeException("Failed to find file " + resourceName); } EPCompiled compiled = EPCompiledIOUtil.Read(new File(file)); var versionMismatchMsg = "Major or minor version of compiler and runtime mismatch; The runtime version is 8.5.1 and the compiler version of the compiled unit is 8.0.0"; AssertMessage( Assert.Throws <EPDeployDeploymentVersionException>( () => env.Runtime.DeploymentService.Deploy(compiled)), versionMismatchMsg); var ex1 = Assert.Throws <EPDeployDeploymentVersionException>( () => env.Runtime.DeploymentService.Rollout(Collections.SingletonList(new EPDeploymentRolloutCompiled(compiled)))); Assert.AreEqual(0, ex1.RolloutItemNumber); AssertMessage(ex1, versionMismatchMsg); AssertMessage( Assert.Throws <EPException>( () => env.Runtime.FireAndForgetService.ExecuteQuery(compiled)), "Major or minor version of compiler and runtime mismatch; The runtime version is 8.5.1 and the compiler version of the compiled unit is 8.0.0"); #endif }
private static void TryInvalidDeploy( RegressionEnvironment env, EPCompiled compiled, string text, string moduleName) { var message = "A precondition is not satisfied: " + text + " has already been created for module '" + moduleName + "'"; try { env.Runtime.DeploymentService.Deploy(compiled); Assert.Fail(); } catch (EPDeployPreconditionException ex) { Assert.That(ex.RolloutItemNumber, Is.EqualTo(-1)); if (!message.Equals("skip")) { SupportMessageAssertUtil.AssertMessage(ex.Message, message); } } catch (EPDeployException) { Assert.Fail(); } }
public static ModuleProviderResult Analyze( EPCompiled compiled, ImportService importService) { var resourceClassName = compiled.Manifest.ModuleProviderClassName; // load module resource class Type clazz; try { clazz = TypeHelper.ResolveType(resourceClassName, true); } catch (Exception e) { throw new EPException(e); } // instantiate ModuleProvider moduleResource; try { moduleResource = (ModuleProvider)TypeHelper.Instantiate(clazz); } catch (EPException) { throw; } catch (Exception e) { throw new EPException(e); } return(new ModuleProviderResult(moduleResource)); }
private static void DeployWithOptionsWUndeploy( RegressionEnvironment env, EPCompiled compiled, DeploymentOptions options) { env.Deploy(compiled, options).UndeployAll(); }
public EPFireAndForgetPreparedQuery PrepareQuery(EPCompiled compiled) { var fafProvider = EPRuntimeHelperFAF.QueryMethod(compiled, _services); var queryMethodProvider = fafProvider.QueryMethodProvider; EPRuntimeHelperFAF.ValidateSubstitutionParams(queryMethodProvider); var queryMethod = queryMethodProvider.QueryMethod; queryMethod.Ready(_services.StatementContextRuntimeServices); return new EPPreparedQueryImpl(_serviceStatusProvider, queryMethodProvider, queryMethod, _services); }
public void Run(RegressionEnvironment env) { string epl = "@Name('s0') select * from SupportBean(TheString = ?::string)"; EPCompiled compiled = env.Compile(epl); DeploymentOptions options = new DeploymentOptions(); options.WithStatementSubstitutionParameter(opt => opt.SetObject(1, "ax")); env.Deploy(compiled, options).AddListener("s0"); RunAssertionSB(env, epl, EQUAL); }
public MyUpdateListener( RegressionEnvironment env, int numThread) { this.env = env; this.numThread = numThread; compiled = env.Compile( "@Name('t" + numThread + "') select * from SupportMarketDataBean where Volume=" + numThread); }
public EPFireAndForgetQueryResult ExecuteQuery( EPCompiled compiled, ContextPartitionSelector[] contextPartitionSelectors) { if (contextPartitionSelectors == null) { throw new ArgumentException("No context partition selectors provided"); } return ExecuteQueryUnprepared(compiled, contextPartitionSelectors); }
public void Add( string deploymentId, int statementIdFirstStatement, EPCompiled compiled, IDictionary<int, object> userObjectsRuntime, IDictionary<int, string> statementNamesWhenProvidedByAPI, IDictionary<int, IDictionary<int, object>> substitutionParameters) { // no action }
public static EPDeployment Deploy( EPCompiled compiledStmt, EPRuntime runtime) { try { return runtime.DeploymentService.Deploy(compiledStmt); } catch (EPDeployException e) { throw new EPException(e); } }
public void Run(RegressionEnvironment env) { env.CompileDeploy("@public @buseventtype create json schema SimpleJson(fruit string, size string, color string)"); string epl = "@Name('s0') select fruit, size, color from SimpleJson#keepall"; EPCompiled compiled = env.Compile(epl, new CompilerArguments(env.Runtime.RuntimePath)); env.Deploy(compiled).AddListener("s0"); RunAssertionSimple(env); env.UndeployAll(); }
public EPFireAndForgetPreparedQueryParameterized PrepareQueryWithParameters(EPCompiled compiled) { var fafProvider = EPRuntimeHelperFAF.QueryMethod(compiled, _services); var queryMethodProvider = fafProvider.QueryMethodProvider; var queryMethod = queryMethodProvider.QueryMethod; queryMethod.Ready(_services.StatementContextRuntimeServices); return new EPFireAndForgetPreparedQueryParameterizedImpl( _serviceStatusProvider, queryMethodProvider.SubstitutionFieldSetter, queryMethod, queryMethodProvider.QueryInformationals); }
public void Run(RegressionEnvironment env) { string epl = "create schema MANE as MyAutoNameEvent;\n" + "@Name('s0') select P0 from MANE;\n"; EPCompiled compiled = env.CompileWBusPublicType(epl); env.Deploy(compiled).AddListener("s0"); env.SendEventBean(new MyAutoNameEvent("test"), "MANE"); Assert.AreEqual("test", env.Listener("s0").AssertOneGetNewAndReset().Get("P0")); env.UndeployAll(); }
public DeploymentRecoveryEntry( int statementIdFirstStatement, EPCompiled compiled, IDictionary<int, object> userObjectsRuntime, IDictionary<int, string> statementNamesWhenProvidedByAPI, IDictionary<int, IDictionary<int, object>> substitutionParameters) { StatementIdFirstStatement = statementIdFirstStatement; Compiled = compiled; UserObjectsRuntime = userObjectsRuntime; StatementNamesWhenProvidedByAPI = statementNamesWhenProvidedByAPI; SubstitutionParameters = substitutionParameters; }
public static void TryInvalidDeploy( RegressionEnvironment env, EPCompiled unit, string expected) { try { env.Runtime.DeploymentService.Deploy(unit); Assert.Fail(); } catch (EPDeployException ex) { AssertMessage(ex, expected); } }
private static void DeployWithResolver( RegressionEnvironment env, EPCompiled compiled, string statementName, StatementSubstitutionParameterOption resolver) { var options = new DeploymentOptions().WithStatementSubstitutionParameter(resolver); options.StatementNameRuntime = context => statementName; try { env.Deployment.Deploy(compiled, options); } catch (EPDeployException e) { throw new EPRuntimeException(e); } }
private static void TryInvalidSetObject( RegressionEnvironment env, EPCompiled compiled, Consumer<EPFireAndForgetPreparedQueryParameterized> query, string message) { var parameterized = env.Runtime.FireAndForgetService.PrepareQueryWithParameters(compiled); try { query.Invoke(parameterized); Assert.Fail(); } catch (EPException ex) { AssertMessage(ex.Message, message); } }
public void Run(RegressionEnvironment env) { // Class depending on create-class class RegressionPath path = new RegressionPath(); string epl = "@public create inlined_class \"\"\"\n" + " public class MyUtilX {\n" + " public static string SomeFunction(string parameter) {\n" + " return \"|\" + parameter + \"|\";\n" + " }\n" + " }\n" + "\"\"\""; EPCompiled compiled = env.Compile(epl); path.Add(compiled); string eplInvalid = "inlined_class \"\"\"\n" + " public class MyClassY {\n" + " public static string DoIt(string parameter) {\n" + " return MyUtil.SomeFunction(\">\" + parameter + \"<\");\n" + " }\n" + " }\n" + "\"\"\" \n" + "select MyClassY.DoIt(TheString) as c0 from SupportBean\n"; TryInvalidCompile( env, path, eplInvalid, "Exception processing statement: " + "Failure during module compilation: " + "[(4,20): error CS0103: The name 'MyUtil' does not exist in the current context]"); // create-class depending on create-class eplInvalid = "create inlined_class \"\"\"\n" + " public class MyClassZ {\n" + " public static string DoIt(string parameter) {\n" + " return MyUtil.SomeFunction(\">\" + parameter + \"<\");\n" + " }\n" + " }\n" + "\"\"\""; TryInvalidCompile( env, path, eplInvalid, "Exception processing statement: " + "Failure during module compilation: " + "[(4,20): error CS0103: The name 'MyUtil' does not exist in the current context]"); }
private EPFireAndForgetQueryResult ExecuteQueryUnprepared( EPCompiled compiled, ContextPartitionSelector[] contextPartitionSelectors) { var fafProvider = EPRuntimeHelperFAF.QueryMethod(compiled, _services); var queryMethodProvider = fafProvider.QueryMethodProvider; EPRuntimeHelperFAF.ValidateSubstitutionParams(queryMethodProvider); var queryMethod = queryMethodProvider.QueryMethod; queryMethod.Ready(_services.StatementContextRuntimeServices); var result = queryMethod.Execute( _serviceStatusProvider, queryMethodProvider.SubstitutionFieldSetter, contextPartitionSelectors, _services.ContextManagementService); return new EPQueryResultImpl(result); }
private static void TryInvalidNotVisible( RegressionEnvironment env, EPCompiled compiled) { var path = new RegressionPath(); path.Add(compiled); TryInvalidCompile( env, path, "select 1 from MySchema", "Failed to resolve event type, named window or table by name 'MySchema'"); TryInvalidCompile( env, path, "select abc from SupportBean", "Failed to validate select-clause expression 'abc': Property named 'abc' is not valid in any stream"); TryInvalidCompile( env, path, "context MyContext select * from SupportBean", "Context by name 'MyContext' could not be found"); TryInvalidCompile( env, path, "on SupportBean update MyWindow set TheString = 'a'", "A named window or table 'MyWindow' has not been declared"); TryInvalidCompile( env, path, "into table MyTable select count(*) as c from SupportBean", "Invalid into-table clause: Failed to find table by name 'MyTable'"); TryInvalidCompile( env, path, "select MyExpr() from SupportBean", "Failed to validate select-clause expression 'MyExpr()': Unknown single-row function, expression declaration, script or aggregation function named 'MyExpr' could not be resolved"); TryInvalidCompile( env, path, "select myscript(1) from SupportBean", "Failed to validate select-clause expression 'myscript(1)': Unknown single-row function, aggregation function or mapped or indexed property named 'myscript' could not be resolved"); TryInvalidCompile( env, path, "select MyClassX.DoIt() from SupportBean", "Failed to validate select-clause expression 'MyClassX.DoIt()': Failed to resolve 'MyClassX.DoIt' to a property, single-row function, aggregation function, script, stream or class name"); }
private static void TryOptimizableBoolean( RegressionEnvironment env, RegressionPath path, string epl) { // test function returns lookup value and "Equals" int count = 10; for (int i = 0; i < count; i++) { EPCompiled compiled = env.Compile("@Name('s" + i + "')" + epl, path); EPDeploymentService admin = env.Runtime.DeploymentService; try { admin.Deploy(compiled); } catch (EPDeployException) { Assert.Fail(); } } env.Milestone(0); SupportUpdateListener listener = new SupportUpdateListener(); for (int i = 0; i < 10; i++) { env.Statement("s" + i).AddListener(listener); } var loops = 10000; var delta = PerformanceObserver.TimeMillis( () => { SupportStaticMethodLib.ResetCountInvoked(); for (int i = 0; i < loops; i++) { string key = "E_" + i % 100; env.SendEventBean(new SupportBean(key, 0)); if (key.Equals("E_1")) { Assert.AreEqual(count, listener.NewDataList.Count); listener.Reset(); } else { Assert.IsFalse(listener.IsInvoked); } } }); Assert.AreEqual(loops, SupportStaticMethodLib.CountInvoked); Assert.IsTrue(delta < 1000, "Delta is " + delta); env.UndeployAll(); }
public EPDeployment Deploy( EPCompiled compiled, DeploymentOptions options) { using (_services.Container.EnterContextualReflection()) { if (options == null) { options = new DeploymentOptions(); } ValidateRuntimeAlive(); CheckManifest(-1, compiled.Manifest); DeploymentInternal deployerResult; using (GetDeploymentLock(options)) { var statementIdRecovery = _services.EpServicesHA.StatementIdRecoveryService; var currentStatementId = statementIdRecovery.CurrentStatementId; if (currentStatementId == null) { currentStatementId = 1; } var deploymentId = DeployerHelperResolver.DetermineDeploymentIdCheckExists( -1, options, _runtime.ServicesContext.DeploymentLifecycleService); deployerResult = Deployer.DeployFresh( deploymentId, currentStatementId.Value, compiled, options.StatementNameRuntime, options.StatementUserObjectRuntime, options.StatementSubstitutionParameter, options.DeploymentClassLoaderOption, _runtime); statementIdRecovery.CurrentStatementId = currentStatementId + deployerResult.Statements.Length; // dispatch event DispatchOnDeploymentEvent(deployerResult, -1); } return(MakeDeployment(deployerResult)); } }
/// <summary> /// Write the compiled to a jar file. Overwrites the existing jar file. /// </summary> /// <param name="compiled">compiled</param> /// <param name="file">the target file</param> /// <throws>IOException when the write failed</throws> public static void Write(EPCompiled compiled, FileInfo file) { Manifest manifest = new Manifest(); manifest.MainAttributes.Put(Attributes.Name.MANIFEST_VERSION, "1.0"); manifest.MainAttributes.Put(new Attributes.Name(MANIFEST_COMPILER_VERSION), compiled.Manifest.CompilerVersion); manifest.MainAttributes.Put(new Attributes.Name(MANIFEST_MODULEPROVIDERCLASSNAME), compiled.Manifest.ModuleProviderClassName); manifest.MainAttributes.Put(new Attributes.Name(MANIFEST_QUERYPROVIDERCLASSNAME), compiled.Manifest.QueryProviderClassName); JarOutputStream target = new JarOutputStream(new FileOutputStream(file), manifest); try { foreach (KeyValuePair<string, byte[]> entry in compiled.Classes) { Write(entry.Key, entry.Value, target); } } finally { target.Close(); } }