public void ProcessRequest(HttpContext context)
{
var controller = new FrontController();
var webRequestFactory = new WebRequestFactory();
controller.Handle(webRequestFactory.CreateFrom(context));
}
private void BackgroundGetGitHubVersion(object sender, DoWorkEventArgs e)
{
System.Threading.Thread.Sleep(CHECK_SECONDS_AFTER_STARTUP.SecondsToMilliseconds()); //give DaxStudio a little time to get started up so we don't impede work people are doing with this version check
LastVersionCheck = DateTime.UtcNow;
VersionStatus = "Checking for updates...";
NotifyOfPropertyChange(() => VersionStatus);
try
{
if (_webRequestFactory == null)
{
_webRequestFactory = WebRequestFactory.CreateAsync(_globalOptions, _eventAggregator).Result;
}
PopulateServerVersionFromGithub(_webRequestFactory);
SetVersionStatus();
}
catch (Exception ex)
{
Log.Error("{class} {method} {error}", "VersionCheck", "worker_DoWork", ex.Message);
_eventAggregator.PublishOnUIThread(new ErrorEventArgs(ex));
}
CheckVersion();
}
public void Languages()
{
Settings settings = "123";
var webRequest = new WebRequestFactory(settings);
llist = new LanguageList(webRequest);
llist.Output();
}
public static void Default_1_GetHttpWebRequest_WithEmptyUri()
{
var webRequestFactory = WebRequestFactory.GetInstance();
Assert.NotNull(webRequestFactory);
var webRequest = webRequestFactory.GetHttpWebRequest(null);
Assert.Null(webRequest);
}
public void Default_1_GetHttpWebRequest()
{
var webRequestFactory = WebRequestFactory.GetInstance();
Assert.NotNull(webRequestFactory);
var webRequest = webRequestFactory.GetHttpWebRequest(new Uri("https://www.google.com/search?q=firefox"));
Assert.NotNull(webRequest);
_output.WriteLine("WebRequest.UserAgent: " + webRequest.UserAgent);
}
private WebRequest createWebRequest(string path)
{
int port = IsCorrelation ? 9682 : 9681;
string address = string.Format("https://{0}:{1}{2}", Host, port, path);
WebRequest webRequest = WebRequestFactory.CreateSpotfireWebRequest(new Uri(address));
webRequest.Credentials = new NetworkCredential(UserName, userPass);
return(webRequest);
}
public static async Task PrimeConnectionAsync(string uri, IGlobalOptions globalOptions, IEventAggregator eventAggregator)
{
Log.Debug("{class} {method} {event}", "DaxFormatter", "PrimeConnectionAsync", "Start");
try
{
if (globalOptions.BlockExternalServices)
{
Log.Debug(Common.Constants.LogMessageTemplate, nameof(DaxFormatterProxy), nameof(PrimeConnectionAsync), "Skipping Priming Connection to DaxFormatter.com as External Services are blocked in options");
return;
}
if (redirectHost == null)
{
// www.daxformatter.com redirects request to another site. HttpWebRequest does redirect with GET. It fails, since the web service works only with POST
// The following 2 requests are doing manual POST re-direct
//var webRequestFactory = IoC.Get<WebRequestFactory>();
WebRequestFactory webRequestFactory =
await WebRequestFactory.CreateAsync(globalOptions, eventAggregator);
var redirectRequest = webRequestFactory.Create(uri) as HttpWebRequest;
redirectRequest.AllowAutoRedirect = false;
redirectRequest.Timeout = globalOptions.DaxFormatterRequestTimeout.SecondsToMilliseconds();
try
{
using (var netResponse = await redirectRequest.GetResponseAsync())
{
var redirectResponse = (HttpWebResponse)netResponse;
redirectUrl = redirectResponse.Headers["Location"];
var redirectUri = new Uri(redirectUrl);
// set the shared redirectHost variable
redirectHost = redirectUri.Host;
Log.Debug("{class} {method} Redirected to: {redirectUrl}", "DaxFormatter",
"CallDaxFormatterAsync", uri.ToString());
System.Diagnostics.Debug.WriteLine("Host: " + redirectUri.Host);
}
}
catch (Exception ex)
{
Log.Error("{class} {method} {error}", "DaxFormatter", "PrimeConnectionAsync",
$"Error getting redirect response: {ex.Message}");
}
}
}
catch (Exception ex1)
{
Log.Error("{class} {method} {error}", "DaxFormatter", "PrimeConnectionAsync",
$"Error getting redirect location: {ex1.Message}");
await eventAggregator.PublishOnUIThreadAsync(new OutputMessage(MessageType.Warning,
$"An error occurred while checking the connection to daxformatter.com\n\t{ex1.Message}"));
}
Log.Debug("{class} {method} {event}", "DaxFormatter", "PrimeConnectionAsync", "End");
}
//private void SetVersionStatus()
//{
// if (ServerVersion.IsNotSet() )
// { VersionStatus = "(Unable to get version information)"; }
// else if (LocalVersion.CompareTo(ServerVersion) > 0)
// { VersionStatus = string.Format("(Ahead of {1} Version - {0} )", ServerVersion.ToString(3), ServerVersionType); }
// else if (LocalVersion.CompareTo(ServerVersion) == 0)
// { VersionStatus = string.Format("(Latest {0} Version)", ServerVersionType); }
// else
// { VersionStatus = string.Format("(New {1} Version available - {0})", ServerVersion.ToString(3), ServerVersionType); }
// UpdateCompleteCallback();
// NotifyOfPropertyChange(() => VersionStatus);
//}
// This code runs async in a background worker
private void PopulateServerVersionFromGithub(WebRequestFactory wrf)
{
Log.Information(Common.Constants.LogMessageTemplate, nameof(VersionCheck), nameof(PopulateServerVersionFromGithub), "Start");
using (System.Net.WebClient http = wrf.CreateWebClient())
{
string json = "";
try
{
//#if DEBUG
// json = File.ReadAllText(@"..\..\..\src\CurrentReleaseVersion.json");
//#else
Log.Information(Common.Constants.LogMessageTemplate, nameof(VersionCheck), nameof(PopulateServerVersionFromGithub), "Starting download of CurrentVersion.json");
json = http.DownloadString(new Uri(WebRequestFactory.CurrentGithubVersionUrl));
//#endif
}
catch (System.Net.WebException wex)
{
if (wex.Status == System.Net.WebExceptionStatus.ProtocolError && ((HttpWebResponse)wex.Response).StatusCode == HttpStatusCode.ProxyAuthenticationRequired)
{
Log.Information(Common.Constants.LogMessageTemplate, nameof(VersionCheck), nameof(PopulateServerVersionFromGithub), "Re-trying download of CurrentVersion.json with proxy auth");
// assume proxy auth error and re-try with current user credentials
http.Proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
json = http.DownloadString(new Uri(WebRequestFactory.CurrentGithubVersionUrl));
}
else
{
throw;
}
}
JObject jobj = JObject.Parse(json);
try
{
_productionVersion = Version.Parse((string)jobj["Version"]);
_productionDownloadUrl = new Uri((string)jobj["DownloadUrl"]);
ServerVersionType = "Production";
_globalOptions.CurrentDownloadVersion = _productionVersion;
DownloadUrl = _productionDownloadUrl;
}
catch (Exception ex)
{
Log.Error(ex, Common.Constants.LogMessageTemplate, nameof(VersionCheck), nameof(PopulateServerVersionFromGithub), $"Error parsing CurrentVersion.json: {ex.Message}");
_eventAggregator.PublishOnUIThread(new OutputMessage(MessageType.Warning, $"The following error occurred while checking if there is an updated release available: {ex.Message}"));
}
finally
{
UpdateCompleteCallback?.Invoke();
}
Log.Information(Common.Constants.LogMessageTemplate, nameof(VersionCheck), nameof(PopulateServerVersionFromGithub), "Finish");
}
}
public VersionCheck(IEventAggregator eventAggregator, WebRequestFactory webRequestFactory, IGlobalOptions globalOptions)
{
_eventAggregator = eventAggregator;
_webRequestFactory = webRequestFactory;
_globalOptions = globalOptions;
if (Enabled) // && LastVersionCheck.AddDays(CHECK_EVERY_DAYS) < DateTime.Today)
{
worker.DoWork += new DoWorkEventHandler(worker_DoWork);
worker.RunWorkerAsync();
}
}
public Skype4Sharp(SkypeCredentials loginData, WebProxy loginProxy = null)
{
authInfo = loginData;
mainProxy = loginProxy;
mainFactory = new WebRequestFactory(mainProxy, new CookieContainer());
mainPoll = new Poller(this);
selfProfile = new User(this);
mainUserModule = new UserModule(this);
mainAuthModule = new AuthModule(this);
mainMessageModule = new MessageModule(this);
mainContactModule = new ContactModule(this);
}
private void BackgroundGetGitHubVersion(object sender, DoWorkEventArgs e)
{
try
{
Log.Information(Common.Constants.LogMessageTemplate, nameof(VersionCheck), nameof(BackgroundGetGitHubVersion), "Starting Background Version Check");
_isCheckRunning = true;
UpdateStartingCallback?.Invoke();
//give DaxStudio a little time to get started up so we don't impede work people are doing with this version check
if (_isAutomaticCheck)
{
System.Threading.Thread.Sleep(CHECK_SECONDS_AFTER_STARTUP.SecondsToMilliseconds());
_isAutomaticCheck = false;
}
LastVersionCheck = DateTime.UtcNow;
//VersionStatus = "Checking for updates...";
//NotifyOfPropertyChange(() => VersionStatus);
try
{
if (_webRequestFactory == null)
{
Log.Information(Common.Constants.LogMessageTemplate, nameof(VersionCheck), nameof(BackgroundGetGitHubVersion), "Creating WebRequestFactory");
_webRequestFactory = WebRequestFactory.CreateAsync(_globalOptions, _eventAggregator).Result;
}
Log.Information(Common.Constants.LogMessageTemplate, nameof(VersionCheck), nameof(BackgroundGetGitHubVersion), "Starting Population of version information from Github");
PopulateServerVersionFromGithub(_webRequestFactory);
Log.Information(Common.Constants.LogMessageTemplate, nameof(VersionCheck), nameof(BackgroundGetGitHubVersion), "Updating Version Status");
//SetVersionStatus();
UpdateCompleteCallback?.Invoke();
}
catch (Exception ex)
{
Log.Error("{class} {method} {error}", "VersionCheck", "worker_DoWork", ex.Message);
_eventAggregator.PublishOnUIThread(new ErrorEventArgs(ex));
}
CheckVersion();
}
catch (Exception ex)
{
Log.Error(ex, Common.Constants.LogMessageTemplate, nameof(VersionCheck), nameof(BackgroundGetGitHubVersion), ex.Message);
_eventAggregator.PublishOnUIThread(new OutputMessage(MessageType.Warning, $"Error while checking for updates: {ex.Message}"));
}
finally
{
_isCheckRunning = false;
}
Log.Information(Common.Constants.LogMessageTemplate, nameof(VersionCheck), nameof(BackgroundGetGitHubVersion), "Finished Background Version Check");
}
//private void PopulateServerVersionFromCodeplex()
//{
// System.Net.WebClient http = new System.Net.WebClient();
// //http.Proxy = System.Net.WebProxy.GetDefaultProxy(); //works but is deprecated
// http.Proxy = System.Net.WebRequest.GetSystemWebProxy(); //inherits the Internet Explorer proxy settings. Should help this version check work behind a proxy server.
// MemoryStream ms;
// try
// {
// ms = new MemoryStream(http.DownloadData(new Uri(CURRENT_CODEPLEX_VERSION_URL)));
// }
// catch (System.Net.WebException wex)
// {
// if (wex.Status == System.Net.WebExceptionStatus.ProtocolError)
// {
// // assume proxy auth error and re-try with current user credentials
// http.Proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
// ms = new MemoryStream(http.DownloadData(new Uri(CURRENT_CODEPLEX_VERSION_URL)));
// }
// else
// {
// throw;
// }
// }
// XmlReader reader = XmlReader.Create(ms);
// XmlDocument doc = new XmlDocument();
// doc.Load(reader);
// this._serverVersion = Version.Parse(doc.DocumentElement.SelectSingleNode("Version").InnerText);
// ms.Close();
// reader.Close();
//}
// This code runs async in a background worker
private void PopulateServerVersionFromGithub(WebRequestFactory wrf)
{
using (System.Net.WebClient http = wrf.CreateWebClient())
{
string json = "";
try
{
#if DEBUG
json = File.ReadAllText(@"..\..\..\src\CurrentReleaseVersion.json");
#else
json = http.DownloadString(new Uri(WebRequestFactory.CurrentGithubVersionUrl));
#endif
}
catch (System.Net.WebException wex)
{
if (wex.Status == System.Net.WebExceptionStatus.ProtocolError && ((HttpWebResponse)wex.Response).StatusCode == HttpStatusCode.ProxyAuthenticationRequired)
{
// assume proxy auth error and re-try with current user credentials
http.Proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
json = http.DownloadString(new Uri(WebRequestFactory.CurrentGithubVersionUrl));
}
else
{
throw;
}
}
JObject jobj = JObject.Parse(json);
_productionVersion = Version.Parse((string)jobj["Version"]);
_productionDownloadUrl = (string)jobj["DownloadUrl"];
_prereleaseVersion = Version.Parse((string)jobj["PreRelease"]["Version"]);
_prereleaseDownloadUrl = (string)jobj["PreRelease"]["DownloadUrl"];
if (_globalOptions.ShowPreReleaseNotifcations && _productionVersion.CompareTo(_prereleaseVersion) < 0)
{
ServerVersionType = "Pre-Release";
_serverVersion = _prereleaseVersion;
_downloadUrl = _prereleaseDownloadUrl;
}
else
{
ServerVersionType = "Production";
_serverVersion = _productionVersion;
DownloadUrl = _productionDownloadUrl;
}
}
}
public void WebRequestFactory_CreateWebRequest_CreatesANewWebRequestEachCall()
{
// Arrange
var factory = new WebRequestFactory();
// Act
var request1 = factory.Create("http://localhost");
var request2 = factory.Create("http://localhost");
// Assert
Assert.IsNotNull(request1);
Assert.IsNotNull(request2);
Assert.AreNotSame(request1, request2);
}
public void WebRequestFactory_CreateWebRequest_CreatesANewWebRequestEachCall()
{
// Arrange
var factory = new WebRequestFactory();
// Act
var request1 = factory.Create("http://localhost");
var request2 = factory.Create("http://localhost");
// Assert
Assert.IsNotNull(request1);
Assert.IsNotNull(request2);
Assert.AreNotSame(request1, request2);
}
public void Run(string flightUrl)
{
var startTime = DateTime.Now;
var requestFactory = new WebRequestFactory();
var scraper = new ThomsonScraper(requestFactory, new ThomsonHtmlParser(), new ElasticSearchWriter());
var pagesScraped = 0;
var elasticSearchErrorEncountered = false;
foreach (var departureAirport in ScrapeDepartureAirports(scraper, requestFactory))
{
Console.WriteLine("Finding flights from {0}", departureAirport);
foreach (var query in new ThomsonQueryBuilder().GetFlightQueries(DateTime.Now, 7))
{
if (elasticSearchErrorEncountered)
break;
var formattedUrl = string.Format(flightUrl, departureAirport, query);
Console.WriteLine("Scraping {0}", formattedUrl);
while (formattedUrl != null)
{
try
{
var scrapeResult = Scrape(scraper, requestFactory, formattedUrl);
formattedUrl = GetNextUrl(scrapeResult);
pagesScraped++;
}
catch (ElasticSearchException e)
{
Console.WriteLine(e.Message);
elasticSearchErrorEncountered = true;
break;
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
pagesScraped = 0;
}
}
Console.WriteLine(pagesScraped + " pages scraped");
Console.WriteLine("Ran in " + (DateTime.Now - startTime));
}
static void Main(string[] args)
{
var serializerFactory = new ContentSerializerFactory();
var contentExtractorFactory = new ContentProviderFactory();
var webRequestFactory = new WebRequestFactory(serializerFactory, contentExtractorFactory);
var requestDesigner = new RequestDesigner(webRequestFactory);
while (true)
{
requestDesigner.SetUp();
Console.ReadKey();
Console.Clear();
}
}
public void Test_SecretProviderFactory()
{
var webRequestFactory = new WebRequestFactory();
var serializer = new DefaultJSONSerializer();
var secretProviderFactory = new AzureSecretProviderFactory(webRequestFactory, serializer);
var executionContext = new FakeExecutionContext();
var provider = secretProviderFactory.Create(executionContext);
Assert.AreEqual(26, provider.Count);
var value = provider.GetValue <string>("MySimpleSecret");
Assert.AreEqual("This is a secret", value);
}
public void TestWebServer()
{
const int webserverPort = 20202;
using (var webserver = new WebServer(webserverPort))
{
foreach (var element in plainTextElementResponses)
{
new TestElementResponse(element.Key, element.Value);
}
foreach (var element in plainTextElementResponses)
{
Assert.AreEqual(WebRequestFactory.GetResponseSimple($"http://localhost:{webserver.Port}/{element.Key}", out System.Net.HttpStatusCode statusCode), element.Key);
}
int count = 0;
foreach (var element in complexRelementResponsesContain)
{
new TestElementResponse($"{nameof(complexRelementResponsesContain)}.{count++}.{element.Key.GetType().Name}", element.Key);
}
count = 0;
foreach (var element in complexRelementResponsesContain)
{
foreach (var value in element.Value)
{
Assert.IsTrue(WebRequestFactory.GetResponseSimple($"http://localhost:{webserver.Port}/{nameof(complexRelementResponsesContain)}.{count}.{element.Key.GetType().Name}", out System.Net.HttpStatusCode statusCode).Contains(value));
}
count++;
}
}
Thread.Sleep(500);
Assert.IsTrue(ServerCore.TcpPortIsUnused(webserverPort));
}
public void ServiceBaseGenerates_WebRequestEntities_From_SharedWebRequestFactory()
{
// arrange
var uri = new Uri("http://www.google.com");
var factory = new TestWebRequestFactoryEx();
var user = new UserContract {
Name = "Freddie"
};
factory.RegisterResultForUri(uri.ToString(), user.ToJson()); // if our hook is working then we should get contracts from google and not a search page
WebRequestFactory.SetSharedWebRequestFactory(factory);
// act
var service = new TestServiceBase(new ApiConfiguration("<<clientid>>", "<<clientsecret>>", "<<redirecturl>>"), null, null);
// assert
var contract = service.Get(uri);
Assert.AreNotSame(user, contract);
Assert.AreEqual(user.Name, contract.Name);
}
public static async Task PrimeConnectionAsync(string uri, IGlobalOptions globalOptions, IEventAggregator eventAggregator)
{
await Task.Run(async() =>
{
Log.Debug("{class} {method} {event}", "DaxFormatter", "PrimeConnectionAsync", "Start");
if (redirectHost == null)
{
// www.daxformatter.com redirects request to another site. HttpWebRequest does redirect with GET. It fails, since the web service works only with POST
// The following 2 requests are doing manual POST re-direct
//var webRequestFactory = IoC.Get<WebRequestFactory>();
WebRequestFactory webRequestFactory = await WebRequestFactory.CreateAsync(globalOptions, eventAggregator);
var redirectRequest = webRequestFactory.Create(uri) as HttpWebRequest;
redirectRequest.AllowAutoRedirect = false;
redirectRequest.Timeout = globalOptions.DaxFormatterRequestTimeout.SecondsToMilliseconds();
try
{
using (var netResponse = redirectRequest.GetResponse())
{
var redirectResponse = (HttpWebResponse)netResponse;
redirectUrl = redirectResponse.Headers["Location"];
var redirectUri = new Uri(redirectUrl);
// set the shared redirectHost variable
redirectHost = redirectUri.Host;
Log.Debug("{class} {method} Redirected to: {redirectUrl}", "DaxFormatter", "CallDaxFormatterAsync", uri.ToString());
System.Diagnostics.Debug.WriteLine("Host: " + redirectUri.Host);
}
}
catch (Exception ex)
{
Log.Error("{class} {method} {error}", "DaxFormatter", "PrimeConnectionAsync", ex.Message);
}
}
Log.Debug("{class} {method} {event}", "DaxFormatter", "PrimeConnectionAsync", "End");
});
}
public async Task <WebRequestResponse <T> > GetResponseFromEndpoint <T>(string url, CancellationToken token)
{
if (!networkChecker.HasInternetAccess())
{
return(WebRequestFactory.Cancelled <T>());
}
try
{
var responseString = await GetResponseString(url, token);
var obj = stringDeserializer.Deserialize <T>(responseString);
return(WebRequestFactory.Success(obj));
}
catch (System.Net.WebException)
{
return(WebRequestFactory.Cancelled <T>());
}
catch (HttpRequestException)
{
return(WebRequestFactory.Errored <T>("Internet connection was disrupted."));
}
}
public MainWindow()
{
InitializeComponent();
var webRequestFactory = new WebRequestFactory();
var dispatcherInvokator = new DispatcherInvokator();
var connectionViewModel = InitializeConnectionViewModel();
var urlViewer = new UrlViewerViewModel();
var registeredEventViewModel = InitializeRegistereEventsView(connectionViewModel, urlViewer, webRequestFactory);
var channelsViewModel = InitializeChannelsViewModel(connectionViewModel, urlViewer, webRequestFactory);
InitializeEventUpdaterViewModel(connectionViewModel, registeredEventViewModel, channelsViewModel, urlViewer, webRequestFactory, dispatcherInvokator);
InitialzieArchiveEventsViewModel(connectionViewModel, webRequestFactory, registeredEventViewModel, channelsViewModel, urlViewer);
MainWindowViewModel.UrlViewerViewModel = urlViewer;
DataContext = MainWindowViewModel;
}
private static async Task <string> CallDaxFormatterAsync(string uri, string query, ServerDatabaseInfo serverDbInfo, IGlobalOptions globalOptions, IEventAggregator eventAggregator, bool formatAlternateStyle)
{
Log.Verbose("{class} {method} {uri} {query}", "DaxFormatter", "CallDaxFormatterAsync:Begin", uri, query);
try
{
DaxFormatterRequest req = new DaxFormatterRequest();
req.Dax = query;
if (globalOptions.DefaultSeparator == DaxStudio.Interfaces.Enums.DelimiterType.SemiColon)
{
req.DecimalSeparator = ',';
req.ListSeparator = ';';
}
req.ServerName = Crypto.SHA256(serverDbInfo.ServerName);
req.ServerEdition = serverDbInfo.ServerEdition;
req.ServerType = serverDbInfo.ServerType;
req.ServerMode = serverDbInfo.ServerMode;
req.ServerLocation = serverDbInfo.ServerLocation;
req.ServerVersion = serverDbInfo.ServerVersion;
req.DatabaseName = Crypto.SHA256(serverDbInfo.DatabaseName);
req.DatabaseCompatibilityLevel = serverDbInfo.DatabaseCompatibilityLevel;
if ((globalOptions.DefaultDaxFormatStyle == DaxStudio.Interfaces.Enums.DaxFormatStyle.ShortLine && !formatAlternateStyle)
||
(globalOptions.DefaultDaxFormatStyle == DaxStudio.Interfaces.Enums.DaxFormatStyle.LongLine && formatAlternateStyle)
)
{
req.MaxLineLenght = 1;
}
var data = JsonConvert.SerializeObject(req);
var enc = System.Text.Encoding.UTF8;
var data1 = enc.GetBytes(data);
// this should allow DaxFormatter to work through http 1.0 proxies
// see: http://stackoverflow.com/questions/566437/http-post-returns-the-error-417-expectation-failed-c
//System.Net.ServicePointManager.Expect100Continue = false;
await PrimeConnectionAsync(uri, globalOptions, eventAggregator);
Uri originalUri = new Uri(uri);
string actualUrl = new UriBuilder(originalUri.Scheme, redirectHost, originalUri.Port, originalUri.PathAndQuery).ToString();
//var webRequestFactory = IoC.Get<WebRequestFactory>();
var webRequestFactory = await WebRequestFactory.CreateAsync(globalOptions, eventAggregator);
var wr = webRequestFactory.Create(new Uri(actualUrl));
wr.Timeout = globalOptions.DaxFormatterRequestTimeout.SecondsToMilliseconds();
wr.ContentType = "application/json";
wr.Method = "POST";
wr.Accept = "application/json, text/javascript, */*; q=0.01";
wr.Headers.Add("Accept-Encoding", "gzip,deflate");
wr.Headers.Add("Accept-Language", "en-US,en;q=0.8");
wr.ContentType = "application/json; charset=UTF-8";
wr.AutomaticDecompression = DecompressionMethods.GZip;
string output = "";
using (var strm = await wr.GetRequestStreamAsync())
{
strm.Write(data1, 0, data1.Length);
using (var resp = wr.GetResponse())
{
//var outStrm = new System.IO.Compression.GZipStream(resp.GetResponseStream(), System.IO.Compression.CompressionMode.Decompress);
var outStrm = resp.GetResponseStream();
using (var reader = new System.IO.StreamReader(outStrm))
{
output = await reader.ReadToEndAsync();
}
}
}
return(output);
}
catch (Exception ex)
{
Log.Error("{class} {method} {message}", "DaxFormatter", "CallDaxFormatterAsync", ex.Message);
throw;
}
finally
{
Log.Debug("{class} {method}", "DaxFormatter", "CallDaxFormatterAsync:End");
}
}
private async Task <Response> SendInternalAsync(Request request, WebRequestState state, TimeSpan?connectionTimeout, CancellationToken cancellationToken)
{
CancellationTokenRegistration registration;
try
{
registration = cancellationToken.Register(state.CancelRequest);
}
catch (ObjectDisposedException)
{
return(Responses.Canceled);
}
using (registration)
using (state)
{
if (state.RequestCanceled)
{
return(Responses.Canceled);
}
state.Request = WebRequestFactory.Create(request, state.TimeRemaining, Settings, log);
HttpActionStatus status;
// Step 1: send request body if it was supplied in request.
if (state.RequestCanceled)
{
return(Responses.Canceled);
}
if (request.HasBody)
{
status = await connectTimeLimiter
.LimitConnectTime(SendRequestBodyAsync(request, state, cancellationToken), request, state, connectionTimeout)
.ConfigureAwait(false);
if (status != HttpActionStatus.Success)
{
return(responseFactory.BuildFailureResponse(status, state));
}
}
// Step 2: receive response from server.
if (state.RequestCanceled)
{
return(Responses.Canceled);
}
status = request.HasBody
? await GetResponseAsync(request, state).ConfigureAwait(false)
: await connectTimeLimiter.LimitConnectTime(GetResponseAsync(request, state), request, state, connectionTimeout).ConfigureAwait(false);
if (status != HttpActionStatus.Success)
{
return(responseFactory.BuildFailureResponse(status, state));
}
// Step 3 - download request body if it exists.
if (!NeedToReadResponseBody(request, state))
{
return(responseFactory.BuildSuccessResponse(state));
}
if (ResponseBodyIsTooLarge(state))
{
state.CancelRequestAttempt();
return(responseFactory.BuildResponse(ResponseCode.InsufficientStorage, state));
}
if (state.RequestCanceled)
{
return(Responses.Canceled);
}
if (NeedToStreamResponseBody(state))
{
state.ReturnStreamDirectly = true;
state.PreventNextDispose();
return(responseFactory.BuildSuccessResponse(state));
}
status = await ReadResponseBodyAsync(request, state, cancellationToken)
.ConfigureAwait(false);
return(status == HttpActionStatus.Success
? responseFactory.BuildSuccessResponse(state)
: responseFactory.BuildFailureResponse(status, state));
}
}
public override IPluginWebRequest CreateWebRequest(Uri address, string dependencyName = null)
{
return(WebRequestFactory.BuildPluginWebRequest(address, dependencyName, this.TelemetryFactory, this.TelemetryClient));
}
public static void Default_0_GetInstance()
{
var webRequestFactory = WebRequestFactory.GetInstance();
Assert.NotNull(webRequestFactory);
}
