protected void Button1_Click(object sender, EventArgs e) { ReportExecutionService reportExecutionService = new ReportExecutionService(); // Web Service proxy reportExecutionService.Credentials = new NetworkCredential("reportservice", "Asdfghjkl?", "kswh107"); string reportPath = "/ReconCurrent/ReconInvest"; string format = "PDF"; // Render arguments byte[] result = null; string historyID = null; string encoding; string mimeType; string extension; Warning[] warnings = null; string[] streamIDs = null; ParameterValue[] parameters = new ParameterValue[4]; parameters[0] = new ParameterValue(); parameters[0].Name = "StartDate"; parameters[1] = new ParameterValue(); parameters[1].Name = "EndDate"; parameters[2] = new ParameterValue(); parameters[2].Name = "IsinCode"; parameters[3] = new ParameterValue(); parameters[3].Name = "AccountNumber"; ExecutionInfo execInfo = new ExecutionInfo(); ExecutionHeader execHeader = new ExecutionHeader(); reportExecutionService.ExecutionHeaderValue = execHeader; execInfo = reportExecutionService.LoadReport(reportPath, historyID); String SessionId = reportExecutionService.ExecutionHeaderValue.ExecutionID; parameters[0].Value = DatePickerBegin.SelectedDate.ToShortDateString(); parameters[1].Value = DatePickerEnd.SelectedDate.ToShortDateString(); parameters[3].Value = ddlAccount.SelectedValue.ToString(); parameters[2].Value = ddlInstrument.SelectedValue.ToString(); reportExecutionService.SetExecutionParameters(parameters, "nl-nl"); result = reportExecutionService.Render(format, null, out extension, out encoding, out mimeType, out warnings, out streamIDs); Response.ClearContent(); Response.AppendHeader("content-length", result.Length.ToString()); Response.ContentType = "application/pdf"; Response.BinaryWrite(result); Response.End(); //Response.Flush(); //Response.Close(); }
//TODO: get from config.json. Use same source across all usages public ExecutionInfo Start(string tool, string args, int?pause = 2000) { var currentDir = Directory.GetCurrentDirectory(); try { var fileName = Path.GetFileName(tool); EnsureCurrentDirectory(tool, fileName); var exitInfo = ProcessExtensions.LaunchApp(fileName, args); var result = new ExecutionInfo { ProcessId = exitInfo.ProcessId, OutputStrings = exitInfo.Output, ErrorStrings = exitInfo.Errors.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries), ExitCode = exitInfo.ExitCode }; if (pause.HasValue && !exitInfo.IsError) { Thread.Sleep(pause.Value); } return(result); } finally { Directory.SetCurrentDirectory(currentDir); } }
public static ExecutionInfo Execute(string program, string commandLine) { ExecutionInfo e = new ExecutionInfo(); e.CommandLine = program + " " + commandLine; e.Time = Environment.TickCount; e.ErrorLevel = -1; StreamReader outputReader = null; StreamReader errorReader = null; try { ProcessStartInfo processStartInfo = new ProcessStartInfo(program, commandLine); processStartInfo.ErrorDialog = false; processStartInfo.UseShellExecute = false; processStartInfo.RedirectStandardError = true; processStartInfo.RedirectStandardInput = false; processStartInfo.RedirectStandardOutput = true; processStartInfo.CreateNoWindow = true; processStartInfo.WindowStyle = ProcessWindowStyle.Normal; Process process = new Process(); process.StartInfo = processStartInfo; bool processStarted = process.Start(); if (processStarted) { outputReader = process.StandardOutput; errorReader = process.StandardError; process.WaitForExit(); e.ErrorLevel = process.ExitCode; e.Output = outputReader.ReadToEnd(); e.ErrorOutput = errorReader.ReadToEnd(); } } catch (Exception ex) { e.ErrorOutput += "Error lanching the {0} = {1}".format(e.CommandLine, ex.ToString()); } finally { if (outputReader != null) { outputReader.Close(); } if (errorReader != null) { errorReader.Close(); } if (e.ErrorLevel != 0) { e.ErrorOutput = e.Output; e.Output = ""; } } e.Time = Environment.TickCount - e.Time; return(e); }
public void ResetExecution() { Snapshot = null; EventInfo = null; CompiledDataSources = null; ExecutionInfo.Reset(); }
public override bool Execute(ExecutionInfo exInfo = null) { ElementSet set = Model.Sets.FindOrCreate <ElementSet>(Name); set.Set(Elements); return(true); }
public void ShouldNotFetchDuplicateTags() { var specInfo = new SpecInfo { Tags = { "foo" }, Name = "", FileName = "", IsFailed = false }; var scenarioInfo = new ScenarioInfo { Tags = { "foo" }, Name = "", IsFailed = false }; var currentScenario = new ExecutionInfo { CurrentSpec = specInfo, CurrentScenario = scenarioInfo }; var tags = AssertEx.ExecuteProtectedMethod <ScenarioExecutionStartingProcessor>("GetApplicableTags", currentScenario) .ToList(); Assert.IsNotEmpty(tags); Assert.AreEqual(1, tags.Count); Assert.Contains("foo", tags); }
public RSExecutionInfo SetExecutionCredentials(RSDataSourceCredentials[] Credentials) { DataSourceCredentials[] dsCredentials = (DataSourceCredentials[])Converter.Convert(Credentials); ExecutionInfo outval = rs.SetExecutionCredentials(dsCredentials); return((RSExecutionInfo)Converter.Convert(outval)); }
public RSExecutionInfo SetExecutionParameters(RSParameterValue[] Parameters, string ParameterLanguage) { ParameterValue[] paramValues = (ParameterValue[])Converter.Convert(Parameters); ExecutionInfo outval = rs.SetExecutionParameters(paramValues, ParameterLanguage); return((RSExecutionInfo)Converter.Convert(outval)); }
public override bool Execute(ExecutionInfo exInfo = null) { BuildUp = Model.Create.BuildUpFamily(Name, exInfo); BuildUp.Layers.Clear(); BuildUp.Layers.Add(new BuildUpLayer(Thickness, Material)); return(true); }
protected bool ExtractOutputs(IAction action, IGH_DataAccess DA, ExecutionInfo exInfo) { IList <PropertyInfo> outputs = ActionBase.ExtractOutputParameters(ActionType); foreach (PropertyInfo pInfo in outputs) { object outputData = pInfo.GetValue(action, null); if (PreviewLayer != null) { if (outputData is ICollection) //TODO: This would currently catch mesh faces and other similar objects... { PreviewLayer.TryRegisterAll((ICollection)outputData); } else { PreviewLayer.TryRegister(outputData); } } outputData = FormatForOutput(outputData, exInfo); if (outputData is IList) { DA.SetDataList(pInfo.Name, (IEnumerable)outputData); } else { DA.SetData(pInfo.Name, outputData); } } return(true); }
public static Tuple<bool, string> ExecuteCommand(ExecutionInfo ei) { // Start the child process. var p = new Process(); // Redirect the output stream of the child process. p.StartInfo.UseShellExecute = false; p.StartInfo.RedirectStandardOutput = true; p.StartInfo.RedirectStandardError = true; p.StartInfo.FileName = ei.FileName; p.StartInfo.Arguments = ei.Arguments; // Hide Window p.StartInfo.CreateNoWindow = true; p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden; p.Start(); // Do not wait for the child process to exit before // reading to the end of its redirected stream. // p.WaitForExit(); // Read the output stream first and then wait. var output = p.StandardOutput.ReadToEnd(); var error = p.StandardError.ReadToEnd(); p.WaitForExit(); return new Tuple<bool, string>(p.ExitCode == 0, output + error); }
public ExecutionResult Execute(string hookType, IHooksStrategy strategy, IList <string> applicableTags, ExecutionInfo info) { var methods = GetHookMethods(hookType, strategy, applicableTags); var executionResult = new ExecutionResult { Success = true }; foreach (var method in methods) { var methodInfo = _registry.MethodFor(method); try { var context = _executionInfoMapper.ExecutionContextFrom(info); ExecuteHook(methodInfo, context); } catch (Exception ex) { Logger.Debug($"{hookType} Hook execution failed : {methodInfo.DeclaringType.FullName}.{methodInfo.Name}"); var innerException = ex.InnerException ?? ex; executionResult.ExceptionMessage = innerException.Message; executionResult.StackTrace = innerException.StackTrace; executionResult.Source = innerException.Source; executionResult.Success = false; } } return(executionResult); }
public void ShouldGetEmptyTagListByDefault() { var specInfo = SpecInfo.CreateBuilder() .AddTags("foo") .SetName("") .SetFileName("") .SetIsFailed(false) .Build(); var scenarioInfo = ScenarioInfo.CreateBuilder() .AddTags("bar") .SetName("") .SetIsFailed(false) .Build(); var currentScenario = ExecutionInfo.CreateBuilder() .SetCurrentScenario(scenarioInfo) .SetCurrentSpec(specInfo) .Build(); var currentExecutionInfo = ScenarioExecutionStartingRequest.CreateBuilder() .SetCurrentExecutionInfo(currentScenario) .Build(); var message = Message.CreateBuilder() .SetScenarioExecutionStartingRequest(currentExecutionInfo) .SetMessageType(Message.Types.MessageType.ScenarioExecutionStarting) .SetMessageId(0) .Build(); var tags = AssertEx.ExecuteProtectedMethod <ExecutionEndingProcessor>("GetApplicableTags", message); Assert.IsEmpty(tags); }
/// <summary> /// Store a generated object keyed by the given execution info of its generating action /// </summary> /// <param name="exInfo"></param> /// <param name="unique"></param> public void Set(ExecutionInfo exInfo, ModelObject unique) { if (exInfo != null && exInfo.SourceReference != null) { IList <IList <ModelObject> > iterations; if (SourceMap.ContainsKey(exInfo.SourceReference)) { iterations = SourceMap[exInfo.SourceReference]; } else { iterations = new List <IList <ModelObject> >(); SourceMap[exInfo.SourceReference] = iterations; } while (exInfo.Iteration >= iterations.Count) { iterations.Add(null); } IList <ModelObject> iteration = iterations[exInfo.Iteration]; if (iteration == null) { iteration = new List <ModelObject>(); iterations[exInfo.Iteration] = iteration; } if (exInfo.HistoryItemCount < iteration.Count) { iteration[exInfo.HistoryItemCount] = unique; } else { iteration.Add(unique); } exInfo.HistoryItemCount++; } }
//private rs2005.ReportingService2005 rs; public ReporteSSRS(ConexionAFuenteDatos Conexion, Parametros Param) { _SrvrName = Conexion.ServerAddress; _DbName = Conexion.Intercompany; _IdUsuario = Conexion.Usuario; _Password = Conexion.Password; _IntegratedSecurity = Conexion.IntegratedSecurity; _rutaYReporteSSRS = Param.rutaReporteSSRS; _listaDefParamReporte = Param.ListaParametrosRepSSRS; _param = Param; try { _rsExec = new ReportExecutionService(); // Create a new proxy to the web service _rsExec.Credentials = CredentialCache.DefaultCredentials; // Authenticate to the Web service using Windows credentials if (Param.reporteador.Equals("SSRS")) { _rsExec.Url = Param.SSRSServer + "/ReportExecution2005.asmx"; // Assign the URL of the Web service _ei = _rsExec.LoadReport(_rutaYReporteSSRS, _historyID); // Load the selected report. } } catch (Exception Rp) { ultimoMensaje = "Error al inicializar el reporte [ReporteSSRS]" + Rp.Message; numError++; } }
public void ShouldNotGetDuplicateTags() { var specInfo = SpecInfo.CreateBuilder() .AddTags("foo") .SetName("") .SetFileName("") .SetIsFailed(false) .Build(); var scenarioInfo = ScenarioInfo.CreateBuilder() .AddTags("foo") .SetName("") .SetIsFailed(false) .Build(); var currentScenario = ExecutionInfo.CreateBuilder() .SetCurrentScenario(scenarioInfo) .SetCurrentSpec(specInfo) .Build(); var currentExecutionInfo = ScenarioExecutionEndingRequest.CreateBuilder() .SetCurrentExecutionInfo(currentScenario) .Build(); var message = Message.CreateBuilder() .SetScenarioExecutionEndingRequest(currentExecutionInfo) .SetMessageType(Message.Types.MessageType.ScenarioExecutionEnding) .SetMessageId(0) .Build(); var tags = AssertEx.ExecuteProtectedMethod <ScenarioExecutionEndingProcessor>("GetApplicableTags", message).ToList(); Assert.IsNotEmpty(tags); Assert.AreEqual(1, tags.Count); Assert.Contains("foo", tags); }
public void TriggerQueueView_History_IsHistoryExpanded_True() { var resourceId = Guid.NewGuid(); var executionInfo = new ExecutionInfo(DateTime.Now, DateTime.Now - DateTime.UtcNow, DateTime.Today, QueueRunStatus.Success, Guid.NewGuid(), ""); var history = new List <IExecutionHistory> { new ExecutionHistory(resourceId, "output", executionInfo, "username") }; var mockServer = new Mock <IServer>(); var mockResourceRepository = new Mock <IResourceRepository>(); mockResourceRepository.Setup(resourceRepository => resourceRepository.GetTriggerQueueHistory(resourceId)).Returns(history); mockServer.Setup(server => server.ResourceRepository).Returns(mockResourceRepository.Object); var triggerQueueView = new TriggerQueueView(mockServer.Object, new SynchronousAsyncWorker()) { TriggerId = resourceId, ResourceId = resourceId, IsHistoryExpanded = true }; Assert.IsNotNull(triggerQueueView.History); Assert.AreEqual(1, triggerQueueView.History.Count); Assert.IsFalse(triggerQueueView.IsProgressBarVisible); mockResourceRepository.Verify(resourceRepository => resourceRepository.GetTriggerQueueHistory(resourceId), Times.Exactly(1)); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { Host.EnsureInitialisation(); LastExecuted = null; if (ActionType != null) { IAction action = (IAction)Activator.CreateInstance(ActionType, true); if (action != null) { if (action is IModelDocumentAction && !GrasshopperManager.Instance.AutoBake) { IModelDocumentAction mDAction = (IModelDocumentAction)action; mDAction.Document = GrasshopperManager.Instance.BackgroundDocument(OnPingDocument()); } if (ExtractInputs(action, DA)) { ExecutionInfo exInfo = new ExecutionInfo(InstanceGuid.ToString(), DA.Iteration); if (action.PreExecutionOperations(exInfo)) { if (action.Execute(exInfo)) { if (action.PostExecutionOperations(exInfo)) { ExtractOutputs(action, DA, exInfo); LastExecuted = action; LastExecutionInfo = exInfo; } } } } } } }
/// <summary> /// Crea ed esegue un singolo task /// </summary> /// <param name="urlServer"></param> /// <param name="job2Execute"></param> /// <returns></returns> private Task <FeedbackInfo> CreateTask(int taskID, string urlServer, JobInfo job2Execute) { return(Task.Run(() => { FeedbackInfo feedback = new FeedbackInfo() { TaskID = taskID, Name = job2Execute.Name }; WebClient webClient = CreateHttpClient(urlServer); //lista parametri condivisa tra le call (serve per recuperare i parametri da una chiamata e passarli alla successiva) Dictionary <string, string> parameters = new Dictionary <string, string> { { "##server##", "/api" }, { "##sessionID##", taskID.ToString() } }; foreach (string call in job2Execute.Calls) { ExecutionInfo result = ExecuteCall(webClient, call, parameters); feedback.Executions.Add(result); } return feedback; })); }
/// <summary> /// Crea ed esegue un singolo task /// </summary> /// <param name="url"></param> /// <param name="job2Execute"></param> /// <returns></returns> private Task <FeedbackInfo> CreateTask(string url, JobInfo job2Execute) { return(Task.Run(async() => { FeedbackInfo feedback = new FeedbackInfo() { Name = job2Execute.Name }; HttpClient httpClient = CreateHttpClient(url); //lista parametri condivisa tra le call (serve per recuperare i parametri da una chiamata e passarli alla successiva) Dictionary <string, string> parameters = new Dictionary <string, string>(); foreach (var call in job2Execute.Calls) { ExecutionInfo result = await ExecuteCall(httpClient, call, parameters); feedback.Executions.Add(result); } return feedback; }).ContinueWith(res => { return new FeedbackInfo() { Name = job2Execute.Name }; }, TaskContinuationOptions.OnlyOnFaulted)); }
/// <summary> /// Returns an enumerator that iterates through the <see cref="TableQuery{TElement}"/>. /// </summary> /// <returns>An <see cref="IEnumerator{TElement}"/> for the <see cref="TableQuery{TElement}"/>.</returns> public virtual IEnumerator <TElement> GetEnumerator() { if (this.Expression == null) { TableRequestOptions defaultRequestOptions = TableRequestOptions.ApplyDefaults(null, this.queryProvider.Table.ServiceClient); // TODO should we just throw here? // Standard Query Mode return(this.ExecuteInternal(this.queryProvider.Table.ServiceClient, this.queryProvider.Table, defaultRequestOptions, null /* OperationContext */).GetEnumerator()); } else { ExecutionInfo executionInfo = this.Bind(); if (executionInfo.Resolver != null) { // Execute the query. return(this.ExecuteInternal <TElement>(this.queryProvider.Table.ServiceClient, this.queryProvider.Table, executionInfo.Resolver, executionInfo.RequestOptions, executionInfo.OperationContext).GetEnumerator()); } else { return(this.ExecuteInternal(this.queryProvider.Table.ServiceClient, this.queryProvider.Table, executionInfo.RequestOptions, executionInfo.OperationContext).GetEnumerator()); } } }
/// <summary> /// Replace the previous data stored with this execution information with the specified new value. /// If a stored object exists and is of the same type as the new one, it will be updated to match the new values /// otherwise the record will be replaced with the new object. /// </summary> /// <param name="exInfo">The execution information for the current operation</param> /// <param name="unique">The potential new item</param> /// <returns>The current object - either the orginal stored value if it was updated, or the new object /// if it was replaced</returns> public TModelObject Update <TModelObject>(ExecutionInfo exInfo, TModelObject unique) where TModelObject : ModelObject { if (exInfo != null) { ModelObject original = Get(exInfo); if (original != null && unique != null && original is TModelObject) { //original.CopyFieldsFrom(unique); original.Undelete(); exInfo.HistoryItemCount++; return((TModelObject)original); } else { if (unique != null) { Set(exInfo, unique); } else { exInfo.HistoryItemCount++; } if (original != null) { original.Delete(); } return(unique); } } else { return(unique); } }
public void ShouldGetEmptyTagListByDefault() { var specInfo = new SpecInfo { Tags = { "foo" }, Name = "", FileName = "", IsFailed = false }; var scenarioInfo = new ScenarioInfo { Tags = { "bar" }, Name = "", IsFailed = false }; var currentScenario = new ExecutionInfo { CurrentScenario = scenarioInfo, CurrentSpec = specInfo }; var currentExecutionInfo = new ScenarioExecutionStartingRequest { CurrentExecutionInfo = currentScenario }; var message = new Message { ScenarioExecutionStartingRequest = currentExecutionInfo, MessageType = Message.Types.MessageType.ScenarioExecutionStarting, MessageId = 0 }; var tags = AssertEx.ExecuteProtectedMethod <ExecutionStartingProcessor>("GetApplicableTags", message); Assert.IsEmpty(tags); }
public override bool Execute(ExecutionInfo exInfo = null) { LoadCase lCase = Model.LoadCases.FindByName(Case); if (lCase == null || lCase.IsDeleted) { lCase = Model.Create.LoadCase(Case, exInfo); } GravityLoad nLoad = Model.Create.GravityLoad(lCase, exInfo); nLoad.Name = Name; //nLoad.Axes = Axes; nLoad.Direction = Direction; nLoad.Value = Value; if (ApplyTo == null) { nLoad.AppliedTo.Clear(); nLoad.AppliedTo.All = true; } else { nLoad.AppliedTo.Set(ApplyTo); } Load = nLoad; return(true); }
private void TimerCallback(object state) { Action executeAction = null; lock (m_lockObj) { if (m_executionInfo != null) { if (DateTime.Now - m_executionInfo.Timestamp >= TimeSpan.FromMilliseconds(m_delay)) { Debug.WriteLine("Action is set to be executed."); executeAction = m_executionInfo.Action; m_executionInfo = null; ChangeTimer(false); } } } if (executeAction != null) { try { executeAction(); } catch (Exception exc) { //Logger.Instance.Error("Exeption during delayed execution", exc); } } }
public static ExecutionInfo RunCompiler(string srcPath, ProcessInfo compilerProcessInfo) { var embedObjs = new EmbedmentObjectDictionary <string>(); embedObjs.UpdateObject("srcPath", srcPath); var execInfo = new ExecutionInfo(); var proc = new Process { StartInfo = compilerProcessInfo.CreateProcessStartInfo(embedObjs) }; proc.Start(); proc.WaitForExit(); execInfo.SetMemoryNoData(); execInfo.SetTime(proc.UserProcessorTime.TotalMilliseconds, "ms"); execInfo.ExitCode = proc.ExitCode; execInfo.stdout = proc.StandardOutput.ReadToEnd(); execInfo.stderr = proc.StandardError.ReadToEnd(); proc.Close(); return(execInfo); }
public override bool Execute(ExecutionInfo exInfo = null) { Result = false; if (FilePath.IsValid && Write) { if (Options == null) { Options = new RobotConversionOptions(true); } Document.Model.GenerateNodes(new NodeGenerationParameters()); var robot = new RobotController(); robot.Message += HandleMessage; RobotIDMappingTable idMap = null; if (Document.IDMappings.ContainsKey(FilePath)) { idMap = Document.IDMappings[FilePath] as RobotIDMappingTable; } if (idMap == null) { idMap = Document.IDMappings.GetLatest(".rtd") as RobotIDMappingTable; } if (idMap == null) { idMap = new RobotIDMappingTable(); Document.IDMappings.Add(FilePath, idMap); } robot.UpdateRobotFromModel(FilePath, Model, ref idMap, Options); //robot.WriteModelToRobot(FilePath, Document.Model, ref idMap); robot.Close(); robot.Release(); Result = true; } return(true); }
public void ShouldGetTagListFromScenarioAndSpecAndIgnoreDuplicates() { var specInfo = new SpecInfo { Tags = { "foo" }, Name = "", FileName = "", IsFailed = false }; var scenarioInfo = new ScenarioInfo { Tags = { "foo" }, Name = "", IsFailed = false }; var currentScenario = new ExecutionInfo { CurrentScenario = scenarioInfo, CurrentSpec = specInfo }; var currentExecutionInfo = new StepExecutionEndingRequest { CurrentExecutionInfo = currentScenario }; var tags = AssertEx.ExecuteProtectedMethod <StepExecutionEndingProcessor>("GetApplicableTags", currentScenario) .ToList(); Assert.IsNotEmpty(tags); Assert.AreEqual(1, tags.Count); Assert.Contains("foo", tags); }
public async Task <IActionResult> StartInstance(string key, int port) { ExecutionInfo r = await _runner.GetByExecutionInfoKeyAsync(key); if (r != null) { return(BadRequest("Instance is alread running")); } GameInstance instance = _servers.GetById(key); if (instance == null) { return(NotFound(key)); } r = await _runner.StartInstanceAsync("localhost", port, instance); if (r == null) { BadRequest(); } instance.CurrentExecution = r; return(Ok(instance)); }
public async Task <IActionResult> RestartInstace(string key) { ExecutionInfo r = await _runner.GetByExecutionInfoKeyAsync(key); if (r == null) { return(BadRequest("Instance is not running")); } GameInstance instance = _servers.GetById(key); if (instance == null) { NotFound(key); } await _runner.StopInstanceAsync(key); r = await _runner.StartInstanceAsync(r.Hostname, r.Port, instance); if (r == null) { return(BadRequest()); } instance.CurrentExecution = r; return(Ok(instance)); }
public void ShouldGetTagListFromExecutionInfo() { var specInfo = new SpecInfo { Tags = { "foo" }, Name = "", FileName = "", IsFailed = false }; var executionInfo = new ExecutionInfo { CurrentSpec = specInfo }; var currentExecutionInfo = new SpecExecutionEndingRequest { CurrentExecutionInfo = executionInfo }; var message = new Message { SpecExecutionEndingRequest = currentExecutionInfo, MessageType = Message.Types.MessageType.StepExecutionEnding, MessageId = 0 }; var tags = AssertEx.ExecuteProtectedMethod <SpecExecutionEndingProcessor>("GetApplicableTags", message) .ToList(); Assert.IsNotEmpty(tags); Assert.AreEqual(1, tags.Count); Assert.Contains("foo", tags); }
public void ShouldGetEmptyTagListByDefault() { var specInfo = new SpecInfo { Tags = { "foo" }, Name = "", FileName = "", IsFailed = false }; var scenarioInfo = new ScenarioInfo { Tags = { "bar" }, Name = "", IsFailed = false }; var currentScenario = new ExecutionInfo { CurrentScenario = scenarioInfo, CurrentSpec = specInfo }; var tags = AssertEx.ExecuteProtectedMethod <ExecutionStartingProcessor>("GetApplicableTags", currentScenario); Assert.IsEmpty(tags); }
public void Creating_an_execution_info_populated_properties(IOperation operation, Exception error, DateTimeOffset started, DateTimeOffset completed) { var sut = new ExecutionInfo(operation, error, started, completed); Assert.Equal(operation, sut.Operation); Assert.Equal(error, sut.Error); Assert.Equal(started, sut.Started); Assert.Equal(completed, sut.Completed); }
public static ExecutionInfo Execute(string program, string commandLine) { ExecutionInfo e = new ExecutionInfo(); e.CommandLine = program + " " + commandLine; e.Time = Environment.TickCount; e.ErrorLevel = -1; StreamReader outputReader = null; StreamReader errorReader = null; try { ProcessStartInfo processStartInfo = new ProcessStartInfo(program, commandLine); processStartInfo.ErrorDialog = false; processStartInfo.UseShellExecute = false; processStartInfo.RedirectStandardError = true; processStartInfo.RedirectStandardInput = false; processStartInfo.RedirectStandardOutput = true; processStartInfo.CreateNoWindow = true; processStartInfo.WindowStyle = ProcessWindowStyle.Normal; Process process = new Process(); process.StartInfo = processStartInfo; bool processStarted = process.Start(); if (processStarted) { outputReader = process.StandardOutput; errorReader = process.StandardError; process.WaitForExit(); e.ErrorLevel = process.ExitCode; e.Output = outputReader.ReadToEnd(); e.ErrorOutput = errorReader.ReadToEnd(); } } catch (Exception ex) { e.ErrorOutput += "Error lanching the {0} = {1}".format(e.CommandLine, ex.ToString()); } finally { if (outputReader != null) outputReader.Close(); if (errorReader != null) errorReader.Close(); if (e.ErrorLevel != 0) { e.ErrorOutput = e.Output; e.Output = ""; } } e.Time = Environment.TickCount - e.Time; return e; }
///////////////////////////////////////////////////////////////////////////// public RazorRunnerException( RunHow runHow, string error, string razorError, string code ) : base( error ) { // ****** RunContext = runHow; RazorError = razorError; Code = code; // ****** var stackDump = new StringBuilder(); this.ExecutionInfo = ThreadContext.GetExecutionInfo( stackDump, error ); StackDump = stackDump.ToString(); }
protected void Button1_Click(object sender, EventArgs e) { ReportExecutionService reportExecutionService = new ReportExecutionService(); // Web Service proxy reportExecutionService.Credentials = new NetworkCredential("reportservice", "Asdfghjkl?", "kswh107"); string reportPath = "/ReconCurrent/ReconCurrent"; string format = "PDF"; // Render arguments byte[] result = null; string historyID = null; string encoding; string mimeType; string extension; Warning[] warnings = null; string[] streamIDs = null; ExecutionInfo execInfo = new ExecutionInfo(); ExecutionHeader execHeader = new ExecutionHeader(); reportExecutionService.ExecutionHeaderValue = execHeader; execInfo = reportExecutionService.LoadReport(reportPath, historyID); String SessionId = reportExecutionService.ExecutionHeaderValue.ExecutionID; result = reportExecutionService.Render(format, null, out extension, out encoding, out mimeType, out warnings, out streamIDs); Response.ClearContent(); Response.AppendHeader("content-length", result.Length.ToString()); Response.ContentType = "application/pdf"; Response.BinaryWrite(result); Response.End(); //Response.Flush(); //Response.Close(); }
public void TakeFreeCell(ExecutionInfo[] executionInfos, string[] threadNames) { Contract.Require(TplTask == null, "TplTask == null"); Contract.Require(_ownedCellIndex == Free, "_ownedCellIndex == Free"); for (int index = 0; index < executionInfos.Length; index++) { var cell = executionInfos[index]; var cellAlreadyOwned = cell != null; //First check to skip unnecessary CAS operation. if (cellAlreadyOwned) continue; var originalValue = Interlocked.CompareExchange(ref cell, this, null); //Second check for interlocked result; cellAlreadyOwned = originalValue != null; if (cellAlreadyOwned) continue; _ownedCellIndex = index; ThreadName = threadNames[index]; break; } }
/////////////////////////////////////////////////////////////////////////////// public void Trace( ExecutionInfo ei, string fmt, params object [] args ) { System.Diagnostics.Trace.WriteLine( Helpers.SafeStringFormat(fmt, args) ); }
/////////////////////////////////////////////////////////////////////////////// public void WriteMessage( ExecutionInfo ei, string fmt, params object [] args ) { Console.WriteLine( Helpers.SafeStringFormat(fmt, args) ); }
/////////////////////////////////////////////////////////////////////////////// public void WriteMessage( ExecutionInfo ei, string msg, params object [] args ) { task.Log.LogMessage( msg, args ); }
private object RunInternal(MethodOverloads methodOverloads, object[] rawParams) { // TODO: Security FileIOPermission phoenixLauncherFile = new FileIOPermission(FileIOPermissionAccess.AllAccess, System.IO.Path.Combine(Core.Directory, "PhoenixLauncher.xml")); phoenixLauncherFile.Deny(); // First create ParameterData array ParameterData[] parameters = new ParameterData[rawParams.Length]; for (int i = 0; i < rawParams.Length; i++) { parameters[i] = new ParameterData(rawParams[i]); } // Get valid overloads (array is never empty) Method[] methods = methodOverloads.FindOverloads(parameters); Exception exception = null; foreach (Method m in methods) { ExecutionInfo info = new ExecutionInfo(m); ExecutionAttribute[] execAttributes = (ExecutionAttribute[])m.MethodInfo.GetCustomAttributes(typeof(ExecutionAttribute), false); try { // Call all Execution attributes for (int i = 0; i < execAttributes.Length; i++) { execAttributes[i].Starting(m); } // Add execution to running list lock (syncRoot) { if (runningExecutions.Count >= Executions.MaxExecutions) { throw new RuntimeException("Executions limit exceeded."); } RuntimeCore.AddAssemblyObject(info, this); runningExecutions.Add(info); try { // Raise Started event executionStarted.Invoke(this, new ExecutionsChangedEventArgs(info)); } catch (Exception e) { Core.ShowMessageBoxAsync("Unhandled exception in Executions.ExecutionStarted event handler.\r\nMessage: " + e.Message, "Warning"); } } // Init thread-dependent classes if (!threadInitialized) { ScriptErrorException.ThreadInit(); WorldData.World.ThreadInit(); Journal.ThreadInit(); threadInitialized = true; } // Invoke try { return m.Invoke(parameters); } catch (System.Reflection.TargetInvocationException e) { // Im interested only in exception thrown by code throw e.InnerException; } } catch (ParameterException e) { exception = e; } catch (ExecutionBlockedException e) { exception = e; } finally { // Remove execution from running list lock (syncRoot) { runningExecutions.Remove(info); RuntimeCore.RemoveAssemblyObject(info); try { // Raise Finished event executionFinished.Invoke(this, new ExecutionsChangedEventArgs(info)); } catch (Exception e) { Core.ShowMessageBoxAsync("Unhandled exception in Executions.ExecutionFinished event handler.\r\nMessage: " + e.Message, "Warning"); } } // Call all Execution attributes for (int i = 0; i < execAttributes.Length; i++) { execAttributes[i].Finished(m); } } } if (exception != null) { throw exception; } else { throw new InternalErrorException(); } }
public ExecutionsChangedEventArgs(ExecutionInfo ei) { executionInfo = ei; }
/////////////////////////////////////////////////////////////////////////////// public void Trace( ExecutionInfo ei, string fmt, params object [] args ) { System.Diagnostics.Trace.WriteLine( string.Format("at Line {0}, in {1}:", ei.Line, ei.FileName) ); System.Diagnostics.Trace.WriteLine( Helpers.SafeStringFormat(fmt, args) ); }
/// <summary> /// This first version of RenderReport is strictly for legacy support of NIFTransferShipment. NIFTransferShipment should be re-worked to use the rendorReport /// version that accepts an array of ParameterValues. /// </summary> /// <param name="reportPath"></param> /// <param name="identifier"></param> /// <returns></returns> public byte[][] renderReport(string reportPath, ParameterValue[] reportParameters) { // Private variables for rendering string historyID = null; ExecutionHeader execHeader = new ExecutionHeader(); try { rs.Timeout = 300000; rs.ExecutionHeaderValue = execHeader; ExecutionInfo execInfo = new ExecutionInfo(); execInfo = rs.LoadReport(reportPath, historyID); if (reportParameters != null) { rs.SetExecutionParameters(reportParameters, "en-us"); } Byte[][] pages = new Byte[0][]; string format = "IMAGE"; int numberOfPages = 1; byte[] currentPageStream = new byte[1] { 0x00 }; // this single byte will prime the while loop string extension = null; string encoding = null; string mimeType = null; string[] streamIDs = null; Warning[] warnings = null; while (currentPageStream.Length > 0) { string deviceInfo = String.Format(@"<DeviceInfo><OutputFormat>EMF</OutputFormat><PrintDpiX>96</PrintDpiX><PrintDpiY>96</PrintDpiY><StartPage>{0}</StartPage></DeviceInfo>", numberOfPages); //Execute the report and get page count. currentPageStream = rs.Render( format, deviceInfo, out extension, out encoding, out mimeType, out warnings, out streamIDs); if (currentPageStream.Length == 0 && numberOfPages == 1) { break; // nothing rendered } if (currentPageStream.Length > 0) { Array.Resize(ref pages, pages.Length + 1); pages[pages.Length - 1] = currentPageStream; numberOfPages++; } } m_numberOfPages = numberOfPages - 1; return pages; } catch (SoapException ex) { eventLog.WriteEntry(ex.Detail.InnerXml, EventLogEntryType.Information, 7001); Console.WriteLine(ex.Detail.InnerXml); } catch (Exception ex) { eventLog.WriteEntry(ex.Message, EventLogEntryType.Information, 7001); Console.WriteLine(ex.Message); } finally { } return null; }
/////////////////////////////////////////////////////////////////////////////// public void Trace( ExecutionInfo ei, string msg, params object [] args ) { // ****** string message = SafeStringFormat( msg, args ); if( null == ei ) { new ExecutionInfo(); } Messages.Add( new NmpResult.HostMessage() { MessageType = TraceMessage, DistressLevel = ei.DistressLevel, FullMessage = ei.FullMessage, Message = message, Line = ei.Line, Column = ei.Column } ); System.Diagnostics.Trace.WriteLine( message ); }
/////////////////////////////////////////////////////////////////////////////// public void WriteMessage( ExecutionInfo ei, string fmt, params object [] args ) { //if( null != ei ) { // Console.WriteLine( "at Line {0}, in {1}:", ei.Line, ei.FileName ); //} // ****** Console.WriteLine( Helpers.SafeStringFormat(fmt, args) ); }
private void TryStartNewThread(IExecutionQueue executor) { BEGIN: if (_disposed) return; //Second check to ensure concurrency threshold would not be exceeded. var currentConcurrency = Interlocked.Increment(ref _currentConcurrency); if (currentConcurrency > _maxConcurrency) { currentConcurrency = Interlocked.Decrement(ref _currentConcurrency); if (currentConcurrency == 0) { goto BEGIN; } return; } ExecutionEnvelope envelope; if (executor == null) { envelope = TakeNextTask(); } else { envelope = executor.Dequeue(); } if (envelope == null) { Interlocked.Decrement(ref _currentConcurrency); return; } if (Logger.IsDebugEnabled) { Logger.Debug("Starting new execution thread."); } var executionInfo = new ExecutionInfo { CurrentTask = envelope }; var tplTask = new Task(PerformTasks, executionInfo); executionInfo.TakeFreeCell(_executionInfos, _threadNames); executionInfo.TplTask = tplTask; tplTask.Start(); }