private async Task <int?> GetOngoingRequestCountAsync([NotNull] Channel channel, [NotNull] string serviceName) { try { _logger.LogDebug("Getting load report from {serviceName} at {channel}...", serviceName, channel); var loadRequest = new LoadReportRequest { ServiceName = serviceName }; LoadReportingGrpc.LoadReportingGrpcClient loadClient = new LoadReportingGrpc.LoadReportingGrpcClient(channel); LoadReportResponse loadReportResponse = await loadClient.ReportLoadAsync(loadRequest); return(loadReportResponse.ServerStats.CurrentRequests); } catch (Exception e) { _logger.LogDebug(e, "Error getting load report from {serviceName}: {errorMessage}", serviceName, e.Message); return(null); } }
public async Task <byte[]> RenderReport(string report, ParameterValue[] parameters, string exportFormat = "PDF") { var binding = new BasicHttpBinding(BasicHttpSecurityMode.TransportCredentialOnly); binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Ntlm; binding.MaxReceivedMessageSize = 100485760; var rsExec = new ReportExecutionServiceSoapClient(binding, new EndpointAddress(url)); var clientCredentials = new NetworkCredential(userName, password); rsExec.ClientCredentials.Windows.AllowedImpersonationLevel = System.Security.Principal.TokenImpersonationLevel.Impersonation; rsExec.ClientCredentials.Windows.ClientCredential = clientCredentials; TrustedUserHeader trustedUserHeader = new TrustedUserHeader(); LoadReportResponse taskLoadReport = null; string historyID = null; taskLoadReport = await rsExec.LoadReportAsync(trustedUserHeader, report, historyID); ExecutionHeader executionHeader = new ExecutionHeader { ExecutionID = taskLoadReport.executionInfo.ExecutionID }; await rsExec.SetExecutionParametersAsync(executionHeader, trustedUserHeader, parameters, null); const string deviceInfo = @"<DeviceInfo><Toolbar>False</Toolbar><SimplePageHeaders>True</SimplePageHeaders></DeviceInfo>"; RenderResponse response = await rsExec.RenderAsync(new RenderRequest(executionHeader, trustedUserHeader, exportFormat ?? "PDF", deviceInfo)); return(response.Result); }
private async Task <LoadReportResponse> LoadReport(ReportExecutionServiceSoapClient rs, TrustedUserHeader trustedHeader, string reportPath) { // Get the report and set the execution header. // Failure to set the execution header will result in this error: "The session identifier is missing. A session identifier is required for this operation." // See https://social.msdn.microsoft.com/Forums/sqlserver/en-US/17199edb-5c63-4815-8f86-917f09809504/executionheadervalue-missing-from-reportexecutionservicesoapclient LoadReportResponse loadResponse = await rs.LoadReportAsync(trustedHeader, reportPath, HistoryId); return(loadResponse); }
private async Task <bool> TryAddLoadReport( [NotNull] ServiceLocation serviceLocation, TimeSpan workerResponseTimeout, [NotNull] ConcurrentBag <QualifiedService> loadReportsByService) { Channel channel = GetChannel(serviceLocation); try { // Check for health first, it might be that the process is running but we have not // started it. if (!await IsHealthy(serviceLocation, channel, workerResponseTimeout)) { return(false); } LoadReportResponse loadReportResponse = await GetLoadReport(serviceLocation, channel, workerResponseTimeout); ProcessUtils.EnsureThreadIdInName(); if (loadReportResponse.ServerStats.RequestCapacity == 0) { _logger.LogDebug( "Service location {serviceLocation} reports 0 capacity. It is ignored.", serviceLocation); return(false); } var qualifiedLocation = new QualifiedService(serviceLocation, loadReportResponse.ServerStats) { KnownLoadRate = loadReportResponse.KnownLoadRate }; loadReportsByService.Add(qualifiedLocation); return(true); } catch (TimeoutException) { _logger.LogDebug( "Service location {serviceLocation} took longer than {timeout}s. It is ignored.", serviceLocation, workerResponseTimeout.TotalSeconds); } catch (Exception e) { _logger.LogWarning(e, "Error checking service health / load report for {serviceLocation}", serviceLocation); _lastException = e; } return(false); }
public override Task <LoadReportResponse> ReportLoad(LoadReportRequest request, ServerCallContext context) { var result = new LoadReportResponse(); var serverStats = new ServerStats(); result.ServerStats = serverStats; try { if (!_loadByService.TryGetValue(request.ServiceName, out IServiceLoad currentLoad)) { // Unknown service; return(Task.FromException <LoadReportResponse>( new RpcException(new Status(StatusCode.OutOfRange, $"Service name {request.ServiceName} not found.")))); } if (currentLoad == null) { // Unknown load or unknown service; return(Task.FromException <LoadReportResponse>( new RpcException(new Status(StatusCode.OutOfRange, $"Service {request.ServiceName} has no load.")))); } result.TimestampTicks = currentLoad.ReportStart.Ticks; result.KnownLoadRate = currentLoad.KnownLoadRate; serverStats.RequestCapacity = currentLoad.ProcessCapacity; serverStats.CurrentRequests = currentLoad.CurrentProcessCount; serverStats.ServerUtilization = currentLoad.ServerUtilization; currentLoad.Reset(); } catch (Exception e) { var rpcException = new RpcException( new Status(StatusCode.Internal, e.ToString()), e.Message); return(Task.FromException <LoadReportResponse>(rpcException)); } return(Task.FromResult(result)); }
private static async Task <LoadReportResponse> GetLoadReport( [NotNull] ServiceLocation serviceLocation, Channel channel, TimeSpan timeout) { var loadRequest = new LoadReportRequest { Scope = serviceLocation.Scope, ServiceName = serviceLocation.ServiceName }; LoadReportingGrpc.LoadReportingGrpcClient loadClient = new LoadReportingGrpc.LoadReportingGrpcClient(channel); LoadReportResponse loadReportResponse = await TaskUtils.TimeoutAfter( GetLoadReport(loadClient, loadRequest), timeout); return(loadReportResponse); }
// https://docs.microsoft.com/en-us/dotnet/api/reportexecution2005.reportexecutionservice.render?view=sqlserver-2016 // https://docs.microsoft.com/en-us/sql/reporting-services/customize-rendering-extension-parameters-in-rsreportserver-config?view=sql-server-ver15 // https://medium.com/@yates.programmer/generating-an-ssrs-report-using-wcf-from-net-core-application-730e22886da3 public async Task <byte[]> Render(string reportPath, string reportType = "PDF", string deviceInfo = null) { if (string.IsNullOrEmpty(reportPath)) { throw new Exception("Missing required reportPath parameter"); } reportType = reportType.ToUpper().Trim(); switch (reportType) { case "PDF": case "EXCEL": case "WORD": case "XML": case "CSV": case "IMAGE": case "HTML4.0": case "MHTML": break; default: throw new Exception("Invalid reportType: " + reportType); } TrustedUserHeader trustedHeader = new TrustedUserHeader(); LoadReportResponse loadReponse = await LoadReport(RSExecutionClient, trustedHeader, reportPath); if (ReportParameters.Count > 0) { await RSExecutionClient.SetExecutionParametersAsync( loadReponse.ExecutionHeader, trustedHeader, ReportParameters.ToArray(), "en-US" ); } var renderRequest = new RenderRequest(loadReponse.ExecutionHeader, trustedHeader, reportType, deviceInfo); RenderResponse response = await RSExecutionClient.RenderAsync(renderRequest); if (response.Warnings != null) { foreach (ReportExecution.Warning warning in response.Warnings) { Warnings.Add( new KeyValuePair <string, string>( warning.Code, String.Format( "Severity: {0} Object: {1} Message: {2}", warning.Severity, warning.ObjectName, warning.Message ) ) ); } } Extension = response.Extension; MimeType = response.MimeType; Encoding = response.Encoding; StreamIds = response.StreamIds; return(response.Result); }
/// <summary> /// step 1 /// </summary> protected void LoadReport(ReportRequest request, ref ReportExecuteResult result) { if (string.IsNullOrEmpty(request.Path)) { throw new ReportException("Please set ReportPath to execute."); } try { if (!string.IsNullOrEmpty(request.SessionId)) { try { if (request.Reset) { var r = ReportClient.ResetExecutionAsync(new ResetExecutionRequest()).GetAwaiter().GetResult(); result.SessionId = r.executionInfo.ExecutionID; } ReportClient.ExecutionHeader.ExecutionID = request.SessionId; var rr = ReportClient.GetExecutionInfoAsync(new GetExecutionInfoRequest()).GetAwaiter().GetResult(); } catch { request.SessionId = null; } } if (string.IsNullOrEmpty(request.SessionId)) { LoadReportRequest request0 = new LoadReportRequest(request.Path, null); LoadReportResponse response = ReportClient.LoadReportAsync(request0).GetAwaiter().GetResult(); try { var match = VersionRegex.Match(response.ServerInfoHeader.ReportServerVersion); if (match.Success) { Versions.TryAdd(this.ReportSettings.ReportServer, Version.Parse(match.Result("$1"))); } } catch { } result.ParametersRequired = response.executionInfo.ParametersRequired; var dict = new Dictionary <string, string>(response.executionInfo.Parameters.Length); if (response.executionInfo.Parameters.Length > 0) { foreach (var p in response.executionInfo.Parameters) { if (p.DefaultValues != null && p.DefaultValues.Length > 0) { dict[p.Name] = p.DefaultValues.SingleOrDefault(); } if (request.Parameters.ContainsKey(p.Name)) { dict[p.Name] = request.Parameters[p.Name]; } } } request.Parameters = dict; result.SessionId = request.SessionId = response.executionInfo.ExecutionID; //ReportClient.ToggleItemAsync() SetParameters(request, result); } } catch (Exception ex) { throw new ReportException("LoadReport error: " + ex.Message, ex); } }