/// <summary>
/// Gets a new HttpWebRequest object for the URL bound to this CsqWebRequest.
/// </summary>
///
/// <returns>
/// An HttpWebRequest.
/// </returns>
public IHttpWebRequest GetWebRequest()
{
IHttpWebRequest request = WebRequestFactory.Create(new Uri(Url));
ApplyOptions(request);
request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
return(request);
}
protected override async Task <Stream> SendRemoteRequestInternalAsync()
{
IHttpWebRequest httpWebRequest = httpWebRequestFactory.Create("https://visualstudio-devdiv-c2s.msedge.net/ab");
httpWebRequest.Method = "GET";
httpWebRequest.CachePolicy = DefaultCachePolicy;
httpWebRequest.ContentType = "application/json";
httpWebRequest.AddHeaders(GetAllFilters());
Stream stream = null;
try
{
CancellationTokenSource tokenSource = new CancellationTokenSource();
Task.Delay(60000).ContinueWith(delegate
{
tokenSource.Cancel();
});
IHttpWebResponse httpWebResponse = await httpWebRequest.GetResponseAsync(tokenSource.Token).ConfigureAwait(false);
if (httpWebResponse.ErrorCode != 0)
{
return(stream);
}
stream = httpWebResponse.GetResponseStream();
return(stream);
}
catch
{
return(stream);
}
}
/// <summary>
/// Send <paramref name="data"/> to <paramref name="serviceUri"/>.
/// </summary>
/// <param name="data">Sending data.</param>
/// <param name="serviceUri">Endpoint to data send.</param>
/// <returns>Response string value.</returns>
private string ExecuteAction(byte[] data, string serviceUri)
{
WebRequest request = _requestFactory.Create(serviceUri);
request.Method = "POST";
request.ContentType = "application/json; charset=utf-8";
request.ContentLength = data.Length;
request.Timeout = 5 * 60 * 1000;
using (Stream stream = request.GetRequestStream()) {
stream.Write(data, 0, data.Length);
}
WebResponse response = request.GetResponse();
using (Stream dataStream = response.GetResponseStream()) {
StreamReader reader = new StreamReader(dataStream);
return(reader.ReadToEnd());
}
}
private string GetAuthCookie()
{
//Set up request, including username and password in form data
IHttpWebRequestProxy req = _httpFactory.Create(LOGINURL);
req.Method = "POST";
req.ContentType = "application/x-www-form-urlencoded";
using (Stream reqStream = req.GetRequestStream())
using (StreamWriter strWriter = new StreamWriter(reqStream))
{
strWriter.Write(String.Format("login={0}&password={1}", _userName, _password));
} //end using
//Grab response
using (IHttpWebResponseProxy resp = req.GetResponse())
{
return(resp.Headers["Set-Cookie"]);
} //end using
}
private IHttpWebRequest CreateWebRequest(string url, string action)
{
var webRequest = _factory.Create(url);
webRequest.Headers = new WebHeaderCollection();
webRequest.Headers.Add("SOAPAction", action);
webRequest.ContentType = ContentType;
webRequest.Accept = MediaTypeNames.Text.Xml;
webRequest.Method = "POST";
return(webRequest);
}
//public virtual IMirthConnectRequest ForUrlParam(string param, string paramVal)
//{
// if (!this.url.Contains("?"))
// this.url += "?" + param + "=" + paramVal;
// else
// this.url += "&" + param + "=" + paramVal;
// return this;
//}
public IMirthConnectResponse Execute()
{
var data = PreparePostData();
var httpRequest = httpRequestFactory.Create(new Uri(url));
httpRequest.Method = "POST";
httpRequest.ContentType = ContentType;
httpRequest.ContentLength = data.Length;
httpRequest.CookieContainer = new CookieContainer();
IncludeAuthCookieIfAvailable(httpRequest);
using (var dataStream = httpRequest.GetRequestStream())
{
dataStream.Write(data, 0, data.Length);
}
try
{
return(new MirthConnectResponse(httpRequest.GetResponse()));
}
catch (WebException ex)
{
const string message = "Mirth returned error processing request";
var remoteError = string.Empty;
if (ex.Response == null)
{
throw new MirthConnectException(message, remoteError, ex);
}
using (var reader = new StreamReader(ex.Response.GetResponseStream()))
{
remoteError = reader.ReadToEnd();
}
throw new MirthConnectException(message, remoteError, ex);
}
}
private HttpStatusCode GetStatus(string url)
{
var request = _webRequestFactory.Create(url);
request.Timeout = 15000;
request.Method = "HEAD";
try
{
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
return(response.StatusCode);
}
}
catch (WebException)
{
return(HttpStatusCode.NotFound);
}
}
/// <summary>
/// Transmit data to the given URI.
/// </summary>
/// <param name="uri"></param>
/// <param name="partsToSend"></param>
/// <returns>A result that includes parsed JMF results if available.</returns>
public IJmfResult Transmit(Uri uri, ITransmissionPartCollection partsToSend)
{
ParameterCheck.ParameterRequired(uri, "uri");
ParameterCheck.ParameterRequired(partsToSend, "partsToSend");
if (partsToSend.Count == 0)
{
throw new PreconditionException(Messages.HttpTransmitter_Transmit_AtLeastOneTransmissionPartIsRequired);
}
if (uri.IsFile || uri.Scheme.ToLower() != "http")
{
throw new PreconditionException(Messages.HttpTransmitter_Transmit_RequiresHttpUrl);
}
try {
var encodingResult = encodingfactory.GetEncodingForTransmissionParts(partsToSend).Encode(partsToSend);
transmissionLogger.Log(new TransmissionData(encodingResult.Stream, encodingResult.ContentType, "Request"));
var request = httpWebRequestFactory.Create(uri, encodingResult.ContentType);
using (var outStream = request.GetRequestStream()) {
encodingResult.Stream.CopyTo(outStream);
}
var response = (HttpWebResponse)request.GetResponse();
try {
var contentType = response.ContentType.NormalizeContentType();
var responseStream = new TempFileStream();
response.GetResponseStream().CopyTo(responseStream);
transmissionLogger.Log(new TransmissionData(responseStream, contentType, "Response"));
var responseParts = encodingfactory.GetEncodingForMimeType(contentType).Decode("httpContent", responseStream,
contentType);
return(new JmfResult(responseParts));
}
finally {
response.Close();
}
}
catch (Exception err) {
logger.Error(string.Format(Messages.HttpTransmitter_Transmit_HttpTransmitter_UnexpectedException, uri), err);
throw;
}
}
private async Task <string> ResolveUrlRedirect(string url, CancellationToken token)
{
IHttpWebRequest httpWebRequest = webRequestFactory.Create(url);
httpWebRequest.Method = "HEAD";
httpWebRequest.AllowAutoRedirect = false;
IHttpWebResponse httpWebResponse = await httpWebRequest.GetResponseAsync(token).ConfigureAwait(false);
if (httpWebResponse.ErrorCode == ErrorCode.NoError && httpWebResponse.Headers != null)
{
string text = httpWebResponse.Headers["Location"];
if (text != null)
{
return(text);
}
throw new TargetedNotificationsException("Could not resolve url redirect (no location header was received)");
}
throw new TargetedNotificationsException($"Could not resolve url redirect ({httpWebResponse.ErrorCode}-{httpWebResponse.StatusCode}-{httpWebResponse.ExceptionCode})");
}
public Result <Ranking> GetRanking(CompetionRankingCommand command)
{
try
{
if (command.Invalid())
{
return("Parâmetros inválidos");
}
var request = _webRequestFactory.Create(string.Format(command.FootballURL, command.CompetitionId));
request.Method = "GET";
request.Headers.Add("X-Auth-Token", command.Token);
using (var response = request.GetResponse())
using (var streamReader = _streamFactory.Create(response.GetResponseStream()))
{
var result = _deserealize.Deserialize(streamReader.ReadToEnd());
if (result == null)
{
return("Competição não encontrada");
}
return(result);
}
}
catch (WebException ex)
{
if (ex.Response == null)
{
return(ex.Message);
}
using (var stream = ex.Response.GetResponseStream())
using (var reader = new StreamReader(stream))
return(reader.ReadToEnd());
}
catch (Exception e)
{
return(e.Message);
}
}
public async Task <T> SendWebRequestAsync <T>(string url,
string method = "POST",
Dictionary <string, object> parameters = null)
{
try
{
var request = _requestFactory.Create(url, parameters, method);
var response = (HttpWebResponse)(await request.GetResponseAsync());
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
var responseObject = _dataFormatter.ParseResponseString <T>(responseString);
return(responseObject.Result);
}
//TODO catch non-general exception for Bad Requests
catch (Exception e)
{
int errorCode = _dataFormatter.FormServerApiErrorCode(e.Message);
throw new ApiRequestException(e.Message, errorCode);
}
}
public string GetEncodingByUrl(string url)
{
if (url == null)
{
throw new ArgumentNullException(nameof(url));
}
var request = _webRequestFactory.Create(url);
request.Method = "GET";
request.Headers.Add("Accept-Encoding", "gzip,deflate");
using (var response = request.GetResponse() as HttpWebResponse)
{
if (response != null)
{
return(response.ContentEncoding);
}
}
return(null);
}
public async Task <HttpWebResponse> GetResponse(HttpRequest options, bool sendFailureResponse = false)
{
options.CancellationToken.ThrowIfCancellationRequested();
var httpWebRequest = _requestFactory.Create(options);
ApplyHeaders(options.RequestHeaders, httpWebRequest);
if (options.RequestStream != null)
{
httpWebRequest.ContentType = options.RequestContentType;
_requestFactory.SetContentLength(httpWebRequest, options.RequestStream.Length);
using (var requestStream = await _requestFactory.GetRequestStreamAsync(httpWebRequest).ConfigureAwait(false))
{
await options.RequestStream.CopyToAsync(requestStream).ConfigureAwait(false);
}
}
else if (!string.IsNullOrEmpty(options.RequestContent) ||
string.Equals(options.Method, "post", StringComparison.OrdinalIgnoreCase))
{
var bytes = Encoding.UTF8.GetBytes(options.RequestContent ?? string.Empty);
httpWebRequest.ContentType = options.RequestContentType ?? "application/x-www-form-urlencoded";
_requestFactory.SetContentLength(httpWebRequest, bytes.Length);
using (var requestStream = await _requestFactory.GetRequestStreamAsync(httpWebRequest).ConfigureAwait(false))
{
await requestStream.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
}
}
Logger.LogDebug(options.Method + " {0}", options.Url);
var requestTime = DateTime.Now;
try
{
options.CancellationToken.ThrowIfCancellationRequested();
var response = await _requestFactory.GetResponseAsync(httpWebRequest, options.Timeout).ConfigureAwait(false);
var httpResponse = (HttpWebResponse)response;
OnResponseReceived(options.Url, options.Method, httpResponse, requestTime);
EnsureSuccessStatusCode(httpResponse);
options.CancellationToken.ThrowIfCancellationRequested();
return(httpResponse);
}
catch (OperationCanceledException ex)
{
var exception = GetCancellationException(options.Url, options.CancellationToken, ex);
throw exception;
}
catch (Exception ex)
{
if (sendFailureResponse)
{
var webException = ex as WebException ?? ex.InnerException as WebException;
if (webException != null)
{
if (webException.Response is HttpWebResponse response)
{
return(response);
}
}
}
throw GetExceptionToThrow(ex, options, requestTime);
}
}
private bool PostBatch(IEnumerable <TraceData> events, bool shouldThrow = true)
{
if (_associatedTraceListener.ServerUrl == null)
{
return(true);
}
var uri = _associatedTraceListener.ServerUrl;
if (!uri.EndsWith("/"))
{
uri += "/";
}
uri += BulkUploadResource;
//var request = (HttpWebRequest)WebRequest.Create(uri);
var request = _httpWebRequestFactory.Create(uri);
request.Method = "POST";
request.ContentType = "application/json; charset=utf-8";
//if (!string.IsNullOrWhiteSpace(ApiKey))
if (!string.IsNullOrEmpty(_associatedTraceListener.ApiKey))
{
//request.Headers.Add(ApiKeyHeaderName, ApiKey);
request.AddHeader(ApiKeyHeaderName, _associatedTraceListener.ApiKey);
}
//var test = new StringWriter();
//test.Write("{\"events\":[");
//SeqPayloadFormatter.ToJson(events, test);
//test.Write("]}");
//var output = test.ToString();
using (var requestStream = request.GetRequestStream())
using (var payload = new StreamWriter(requestStream))
{
payload.Write("{\"events\":[");
SeqPayloadFormatter.ToJson(events, payload);
payload.Write("]}");
}
//using (var response = (HttpWebResponse)request.GetResponse())
using (var response = request.GetResponse())
{
var responseStream = response.GetResponseStream();
if (responseStream == null)
{
throw new WebException("No response was received from the Seq server");
}
using (var reader = new StreamReader(responseStream))
{
var data = reader.ReadToEnd();
if ((int)response.StatusCode >= 300)
{
if (shouldThrow)
{
throw new WebException(string.Format("Received failed response {0} from Seq server: {1}",
response.StatusCode,
data));
}
return(false);
}
return(true);
}
}
}
public override WebResponse GetResponse()
{
this.Method = Method ?? "GET";
_signer.SignWebRequest(this);
return(_httpWebRequestFactory.Create(this));
}
private IHttpWebRequest CreateDuoWebRequest(IHttpWebRequestFactory webRequestFactory, string protocol, string path, HttpWebRequestMethod method)
{
var duoWebRequest = webRequestFactory.Create(new Uri(string.Format(@"{0}://{1}{2}", protocol, _host, path)));
duoWebRequest.Method = method;
duoWebRequest.Accept = "application/json";
duoWebRequest.Timeout = 3 * 60 * 1000;
return duoWebRequest;
}
private async Task <Stream> SendTargetedNotificationsRequestAsync(IEnumerable <string> previouslyCachedRuleIds)
{
Stream stream = null;
apiTimer = Stopwatch.StartNew();
try
{
CancellationTokenSource tokenSource = new CancellationTokenSource();
Task.Delay(10000).ContinueWith(delegate
{
tokenSource.Cancel();
});
CancellationToken cancelToken = CancellationTokenSource.CreateLinkedTokenSource(tokenSource.Token, cancellationTokenSource.Token).Token;
string parameters = await BuildRequestParametersAsync(previouslyCachedRuleIds).ConfigureAwait(false);
IHttpWebRequestFactory httpWebRequestFactory = webRequestFactory;
IHttpWebRequest request = httpWebRequestFactory.Create(await ResolveUrlRedirect("https://go.microsoft.com/fwlink/?LinkId=690387", cancelToken).ConfigureAwait(false));
request.ContentType = "application/json";
request.Method = "POST";
logger.LogVerbose("Sending request to TN backend", parameters);
byte[] postData = Encoding.UTF8.GetBytes(parameters);
request.ContentLength = postData.Length;
Stream postStream = await request.GetRequestStreamAsync().ConfigureAwait(false);
await postStream.WriteAsync(postData, 0, postData.Length, cancelToken).ConfigureAwait(false);
postStream.Close();
IHttpWebResponse httpWebResponse = await request.GetResponseAsync(cancelToken).ConfigureAwait(false);
apiTimer.Stop();
if (httpWebResponse.ErrorCode == ErrorCode.NoError)
{
stream = httpWebResponse.GetResponseStream();
}
else
{
string eventName = "VS/Core/TargetedNotifications/ApiRequestFailed";
string description = "Request failed.";
Dictionary <string, object> dictionary = new Dictionary <string, object>
{
{
"VS.Core.TargetedNotifications.ErrorCode",
httpWebResponse.ErrorCode
},
{
"VS.Core.TargetedNotifications.ApiResponseMs",
apiTimer?.ElapsedMilliseconds
},
{
"VS.Core.TargetedNotifications.Iteration",
queryIteration
}
};
if (httpWebResponse.ErrorCode == ErrorCode.WebExceptionThrown)
{
dictionary.Add("VS.Core.TargetedNotifications.WebExceptionCode", httpWebResponse.ExceptionCode);
}
targetedNotificationsTelemetry.PostDiagnosticFault(eventName, description, null, dictionary);
}
return(stream);
}
catch (Exception exception)
{
apiTimer.Stop();
string eventName2 = "VS/Core/TargetedNotifications/ApiRequestException";
string text = "Sending request to TN backend failed";
Dictionary <string, object> additionalProperties = new Dictionary <string, object>
{
{
"VS.Core.TargetedNotifications.ApiResponseMs",
apiTimer?.ElapsedMilliseconds
},
{
"VS.Core.TargetedNotifications.Iteration",
queryIteration
}
};
logger.LogError(text, exception);
targetedNotificationsTelemetry.PostDiagnosticFault(eventName2, text, exception, additionalProperties);
return(stream);
}
}
public void GetVulnerability(int ossIndexId)
{
var ossIndex = _ossIndexRepository.Select(ossIndexId);
var coordinates = ossIndex.Coordinates;
var endPoint = $"https://ossindex.sonatype.org/api/v3/component-report/{coordinates}"; // TODO ~ read from config
var request = _httpWebRequestFactory.Create(endPoint);
request.Method = WebRequestMethods.Http.Get;
request.ContentType = _contentType;
try
{
using (var response = request.GetResponse())
{
using (var streamReader = new StreamReader(response.GetResponseStream()))
{
var responseString = streamReader.ReadToEnd();
var componentReport = _jsonConvertService.ToObject <ComponentReportModel>(responseString);
// TODO - consideration:
// - perhaps update `dbo.oss_index` if the data has changed
ossIndex.Description = componentReport.description;
ossIndex.Reference = componentReport.reference;
ossIndex.ExpireDate = DateTime.Now.AddMonths(1);
ossIndex.HttpStatus = (int)HttpStatusCode.OK;
_ossIndexRepository.Update(ossIndex);
foreach (var vulnerability in componentReport.vulnerabilities)
{
// TODO
// delete `[vulnuscloud].[dbo].[oss_index_vulnerabilities].[oss_index_id]`
var ossIndexVulnerabilitiesModel = new OssIndexVulnerabilitiesModel()
{
Cve = vulnerability.cve,
CvssScore = vulnerability.cvssScore,
CvssVector = vulnerability.cvssVector,
Description = vulnerability.description,
InsertDate = DateTime.Now,
OssId = vulnerability.id,
OssIndexId = ossIndex.Id,
Reference = vulnerability.reference,
Title = vulnerability.title
};
_ossIndexVulnerabilitiesRepository.Insert(ossIndexVulnerabilitiesModel);
}
}
}
}
catch (WebException ex)
{
if (ex.Response is HttpWebResponse response)
{
if (response.StatusCode == HttpStatusCode.TooManyRequests)
{
ossIndex.HttpStatus = (int)HttpStatusCode.TooManyRequests;
ossIndex.HttpStatusDate = DateTime.Now;
_ossIndexRepository.Update(ossIndex);
// TODO
// Consider
// 1. Throtteling at this point (this method is not async so the user wont know)
// 2. Halt all API calls, defer them for later
// 2 above would need an arcutectual change above
// - a. the user's file content would be uploaded to `oss_index_queue`
// - b. async process run to query for the data
// - c. include this in the reports page so the user is aware the system is still `fetching data`
}
}
}
catch (Exception ex)
{
// TODO
// 1. Consider that http_status would now be 0 for this record.
// 2. logging
}
}
private IHttpWebRequest CreateHttpRequest(Uri uri)
{
var httpWebRequest = HttpWebRequestFactory.Create(uri.ToString());
return(httpWebRequest);
}
public static IHttpWebRequest Create(this IHttpWebRequestFactory webRequestFactory, string url)
{
return(webRequestFactory.Create(new Uri(url)));
}
