private EPStatement CompileDeploy( string epl) { var args = new CompilerArguments(); args.Path.Add(_runtime.RuntimePath); args.Options.AccessModifierNamedWindow = env => NameAccessModifier.PUBLIC; args.Configuration.Compiler.ByteCode.AllowSubscriber = true; var compiled = EPCompilerProvider.Compiler.Compile(epl, args); var deployment = _runtime.DeploymentService.Deploy(compiled); return(deployment.Statements[0]); }
private static EPCompiled CompileRuntimePath( RegressionEnvironment env, string moduleName, string query) { CompilerArguments args = new CompilerArguments(); args.Options.ModuleUses = (_) => new HashSet <string>() { moduleName }; args.Path.Add(env.Runtime.RuntimePath); return(env.Compiler.CompileQuery(query, args)); }
public EPCompiled Compile( bool soda, string epl, CompilerArguments arguments) { if (!soda) { Compile(epl, arguments); } var copy = EplToModel(epl); Assert.AreEqual(epl, copy.ToEPL()); arguments.Configuration = Configuration; return Compile(copy, arguments); }
public static EPDeployment CompileDeploy( EPRuntime epService, string epl) { try { var args = new CompilerArguments(epService.ConfigurationDeepCopy); args.Path.Add(epService.RuntimePath); var compiled = EPCompilerProvider.Compiler.Compile(epl, args); return(epService.DeploymentService.Deploy(compiled)); } catch (Exception ex) { throw new EPRuntimeException(ex); } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { foreach (Airport airport in sectorElements.Airports) { if (airport.Icao == sectorElements.Info.Airport.AirportIcao) { return; } } events.AddEvent( new ValidationRuleFailure("Invalid airport in INFO definition", sectorElements.Info.Airport) ); }
private void RunSampleFireAndForgetQuery(EPRuntime runtime) { var fireAndForget = "select * from MySampleWindow where key1 = 'sample1' and key2 = 'sample2'"; // see values in SampleVirtualDataWindowIndex var compilerArgs = new CompilerArguments(); compilerArgs.Path.Add(runtime.RuntimePath); var compiled = EPCompilerProvider.Compiler.CompileQuery(fireAndForget, compilerArgs); var result = runtime.FireAndForgetService.ExecuteQuery(compiled); Log.Info("Fire-and-forget query returned: " + result.Array[0].Get("key1") + " and " + result.Array[0].Get("key2")); // For assertions against expected results please see the regression test suite }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { List <string> sectors = sectorElements.Sectors.Select(sector => sector.Name).ToList(); foreach (CoordinationPoint point in sectorElements.CoordinationPoints) { if (!sectors.Contains(point.FromSector)) { string message = $"Invalid FROM sector {point.FromSector} for coordination point: {point.GetCompileData(sectorElements)}"; events.AddEvent(new ValidationRuleFailure(message, point)); } } }
public static SectorFileCompiler Create(CompilerArguments arguments, List <IEventObserver> eventObservers) { EventTracker events = new EventTracker(); foreach (IEventObserver observer in eventObservers) { events.AddObserver(observer); } return(new SectorFileCompiler( arguments, events )); }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { foreach (Region region in sectorElements.Regions) { foreach (RegionPoint point in region.Points) { if (point.Colour != null && !ColourValidator.ColourValid(sectorElements, point.Colour)) { string errorMessage = $"Invalid colour value {point.Colour} for region {region.Name}"; events.AddEvent(new ValidationRuleFailure(errorMessage, point)); } } } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { foreach (GroundNetwork groundNetwork in sectorElements.GroundNetworks) { foreach (GroundNetworkRunwayExit exit in groundNetwork.RunwayExits) { if (!RunwayValid(sectorElements, exit.Runway, groundNetwork.Airport)) { string message = $"Invalid ground network runway {groundNetwork.Airport}/{exit.Runway}"; events.AddEvent(new ValidationRuleFailure(message, exit)); break; } } } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { foreach (SidStarRoute sid in sectorElements.SidRoutes) { foreach (RouteSegment segment in sid.Segments) { if (segment.Colour != null && !ColourValidator.ColourValid(sectorElements, segment.Colour)) { string errorMessage = $"Invalid colour value {segment.Colour} in route segment for SID {sid.Identifier}"; events.AddEvent(new ValidationRuleFailure(errorMessage, segment)); } } } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { List <string> checkedFixes = new List <string>(); foreach (Fix fix in sectorElements.Fixes) { if (checkedFixes.Contains(GetFixKey(fix))) { events.AddEvent(new ValidationRuleFailure("Duplicate fix found: " + fix.Identifier, fix)); continue; } checkedFixes.Add(GetFixKey(fix)); } }
public void Run(RegressionEnvironment env) { MyUserObjectResolver.Contexts.Clear(); var args = new CompilerArguments(env.Configuration); args.Options.StatementUserObject = (new MyUserObjectResolver()).GetValue; var epl = "@Name('s0') select * from SupportBean"; env.Compile(epl, args); var ctx = MyUserObjectResolver.Contexts[0]; Assert.AreEqual(epl, ctx.EplSupplier.Invoke()); Assert.AreEqual("s0", ctx.StatementName); Assert.AreEqual(null, ctx.ModuleName); Assert.AreEqual(1, ctx.Annotations.Length); Assert.AreEqual(0, ctx.StatementNumber); }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { List <string> coloursProcessed = new List <string>(); foreach (Colour colour in sectorElements.Colours) { if (coloursProcessed.Contains(colour.Name.ToLower())) { events.AddEvent(new ValidationRuleFailure("Duplicate colourm definition " + colour.Name, colour)); continue; } coloursProcessed.Add(colour.Name.ToLower()); } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { List <string> existingAirports = new List <string>(); foreach (Airport airport in sectorElements.Airports) { if (existingAirports.Contains(airport.Icao)) { events.AddEvent(new ValidationRuleFailure("Duplicate airport " + airport.Icao, airport)); continue; } existingAirports.Add(airport.Icao); } }
private static EPDeployment CreateStmt( RegressionEnvironment env, string epl) { try { var configuration = env.Runtime.ConfigurationDeepCopy; var args = new CompilerArguments(configuration); args.Path.Add(env.Runtime.RuntimePath); var compiled = env.Compiler.Compile(epl, args); return env.Runtime.DeploymentService.Deploy(compiled); } catch (Exception ex) { throw new EPRuntimeException(ex); } }
private static void TryInvalidCompileWConfigure( RegressionEnvironment env, Consumer<Configuration> configurer, string epl, string message) { try { var configuration = env.MinimalConfiguration(); configurer.Invoke(configuration); var args = new CompilerArguments(configuration); env.Compiler.Compile(epl, args); } catch (EPCompileException ex) { SupportMessageAssertUtil.AssertMessage(ex, message); } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { foreach (SidStar sidStar in sectorElements.SidStars) { bool airportExists = sectorElements.Airports .Count(airport => sidStar.Airport == airport.Icao) != 0; if (!airportExists) { string errorMessage = $"Airport {sidStar.Airport} is not valid for {sidStar.Type}/{sidStar.Identifier}"; events.AddEvent(new ValidationRuleFailure(errorMessage, sidStar)); } } }
/** * Check there's valid format and create a date replacement token */ private void ProcessDateReplacement(CompilerArguments arguments, JObject replacement, string tokenToReplace) { JToken formatToken = replacement.SelectToken("format"); if (formatToken == null) { throw new ConfigFileInvalidException($"Missing date format in replace"); } if (formatToken.Type != JTokenType.String) { throw new ConfigFileInvalidException($"Invalid date format in replace, must be a string"); } arguments.TokenReplacers.Add(new TokenDateReplacer(tokenToReplace, formatToken.ToString())); }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { foreach (Sector sector in sectorElements.Sectors) { foreach (SectorActive active in sector.Active) { if (!RunwayValid(sectorElements, active.Runway, active.Airfield)) { string message = $"Invalid ACTIVE runway {active.Airfield}/{active.Runway} on sector {sector.Name}"; events.AddEvent(new ValidationRuleFailure(message, active)); break; } } } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { List <string> keys = new List <string>(); foreach (SidStar sidStar in sectorElements.SidStars) { string sidStarKey = GetKey(sidStar); if (keys.Contains(sidStarKey)) { events.AddEvent(new ValidationRuleFailure("Duplicate SID/STAR " + sidStarKey, sidStar)); continue; } keys.Add(sidStarKey); } }
private static void TryInvalidCompileFAF( RegressionEnvironment env, RegressionPath path, string faf, string expected) { try { var args = new CompilerArguments(env.Configuration); args.Path.AddAll(path.Compileds); env.Compiler.CompileQuery(faf, args); Assert.Fail(); } catch (EPCompileException ex) { AssertMessage(ex, expected); } }
public EPCompiled Compile( string epl, CompilerArguments arguments) { if (arguments == null) { arguments = new CompilerArguments(new Configuration()); } using (arguments.Configuration.Container.EnterContextualReflection()) { try { var module = EPLModuleUtil.ParseInternal(epl, null); IList<Compilable> compilables = new List<Compilable>(); foreach (var item in module.Items.Where(m => !m.IsCommentOnly)) { var stmtEpl = item.Expression; compilables.Add(new CompilableEPL(stmtEpl)); } // determine module name var moduleName = DetermineModuleName(arguments.Options, module); var moduleUses = DetermineModuleUses(moduleName, arguments.Options, module); // get compile services var compileTimeServices = GetCompileTimeServices(arguments, moduleName, moduleUses, false); AddModuleImports(module.Imports, compileTimeServices); // compile return CompilerHelperModuleProvider.Compile( compilables, moduleName, new EmptyDictionary<ModuleProperty, object>(), compileTimeServices, arguments.Options); } catch (EPCompileException) { throw; } catch (ParseException t) { throw new EPCompileException( "Failed to parse: " + t.Message, t, new EmptyList<EPCompileExceptionItem>()); } catch (Exception ex) { throw new EPCompileException(ex.Message, ex, new EmptyList<EPCompileExceptionItem>()); } } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { List <string> controllers = sectorElements.EsePositions.Select(position => position.Identifier).ToList(); foreach (Sector sector in sectorElements.Sectors) { foreach (SectorGuest guest in sector.Guests) { if (!controllers.Contains(guest.Controller)) { string message = $"Invalid GUEST position {guest.Controller} on sector {sector.Name}"; events.AddEvent(new ValidationRuleFailure(message, guest)); break; } } } }
public void SyntaxValidate( Module module, CompilerArguments arguments) { if (arguments == null) { arguments = new CompilerArguments(new Configuration()); } // determine module name var moduleName = DetermineModuleName(arguments.Options, module); var moduleUses = DetermineModuleUses(moduleName, arguments.Options, module); var moduleCompileTimeServices = GetCompileTimeServices(arguments, moduleName, moduleUses, false); var statementNumber = 0; try { foreach (var item in module.Items) { var services = new StatementCompileTimeServices(statementNumber, moduleCompileTimeServices); if (item.IsCommentOnly) { continue; } if (item.Expression != null && item.Model != null) { throw new EPCompileException( "Module item has both an EPL expression and a statement object model"); } if (item.Expression != null) { CompilerHelperSingleEPL.ParseCompileInlinedClassesWalk(new CompilableEPL(item.Expression), services); } else if (item.Model != null) { CompilerHelperSingleEPL.ParseCompileInlinedClassesWalk(new CompilableSODA(item.Model), services); item.Model.ToEPL(); } else { throw new EPCompileException( "Module item has neither an EPL expression nor a statement object model"); } statementNumber++; } } catch (Exception ex) { throw new EPCompileException(ex.Message, ex); } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { List <string> positions = sectorElements.EsePositions.Select(position => position.Identifier).ToList(); foreach (Sector sector in sectorElements.Sectors) { foreach (string position in sector.Owners.Owners) { if (!positions.Contains(position)) { string message = $"Invalid OWNER position {position} on sector {sector.Name}"; events.AddEvent(new ValidationRuleFailure(message, sector)); break; } } } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { foreach (SidStar sidStar in sectorElements.SidStars) { foreach (string waypoint in sidStar.Route) { if (!RoutePointValidator.ValidateEseSidStarPoint(waypoint, sectorElements)) { string message = $"Invalid waypoint {waypoint} on {sidStar.Type} {sidStar.Airport}/{sidStar.Identifier}"; events.AddEvent( new ValidationRuleFailure(message, sidStar) ); } } } }
public static void TryInvalidCompileGraph( EPRuntime epService, string graph, string expected) { try { var args = new CompilerArguments(epService.ConfigurationDeepCopy); args.Path.Add(epService.RuntimePath); EPCompilerProvider.Compiler.Compile(graph, args); Assert.Fail(); } catch (EPCompileException ex) { if (!ex.Message.StartsWith(expected)) { Assert.AreEqual(expected, ex.Message); } } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { List <string> airports = sectorElements.Airports.Select(airport => airport.Icao).ToList(); airports.Add("000A"); foreach (Sector sector in sectorElements.Sectors) { foreach (SectorActive active in sector.Active) { if (!airports.Contains(active.Airfield)) { string message = $"Invalid ACTIVE airport {active.Airfield} on sector {sector.Name}"; events.AddEvent(new ValidationRuleFailure(message, active)); break; } } } }
public void Validate(SectorElementCollection sectorElements, CompilerArguments args, IEventLogger events) { List <string> airports = sectorElements.Airports .Select(airport => airport.Icao) .ToList(); foreach (Runway runway in sectorElements.Runways) { if (!airports.Contains(runway.AirfieldIcao)) { string message = $"Runway {runway.FirstIdentifier}/{runway.ReverseIdentifier} ({runway.AirfieldIcao}) does not match up to a defined airport"; events.AddEvent( new ValidationRuleFailure(message, runway) ); } } }