private IQueryable <TModel> FormFetchQuery <TModel>(FetchParameters <TModel> fetchParameters) where TModel : class
{
Check.NotNull(fetchParameters, "fetchParameters");
// !IMPORTANT! Call order DOES matter!
// 1 Build Query
var queriedItems = Query(fetchParameters);
if (fetchParameters.NoTracking)
{
queriedItems = queriedItems.AsNoTracking();
}
// 2 Sorting
if (fetchParameters.HasSorting())
{
queriedItems = fetchParameters.PerformSorting(queriedItems);
}
else
{
// HACK: https://stackoverflow.com/a/14524571/3469518
// this hack required for paging
queriedItems = queriedItems.OrderBy(x => 0);
}
// 3 Filtering
return(fetchParameters.PerformFiltering(queriedItems));
}
private void FetchAsynch(Object parameters)
{
FetchParameters fetchParameters = (FetchParameters)parameters;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(fetchParameters.Uri);
request.Method = "GET";
request.AutomaticDecompression = DecompressionMethods.GZip;
if (fetchParameters.Headers != null && fetchParameters.Headers.Any())
{
foreach (string key in fetchParameters.Headers.Keys)
{
if (key.ToLower() == "accept")
{
request.Accept = fetchParameters.Headers[key];
}
else if (key.ToLower() == "content-type")
{
request.ContentType = fetchParameters.Headers[key];
}
else if (key.ToLower() == "host")
{
Exception ex = new ArgumentException("Host header value cannot be set in PCL libraries.");
Device.Log.Error(ex);
throw ex;
}
else
{
request.Headers[key] = fetchParameters.Headers[key];
}
}
}
RequestState state = new RequestState()
{
Request = request,
AbsoluteUri = fetchParameters.Uri,
FileName = fetchParameters.FileName,
Downloaded = DateTime.UtcNow,
StatusCode = HttpStatusCode.RequestTimeout,
};
try
{
// Start the asynchronous request.
IAsyncResult result = request.BeginGetResponse(new AsyncCallback(ResponseCallback), state);
if (!allDone.WaitOne(fetchParameters.Timeout))
{
try { request.Abort(); } catch (Exception) { } // .Abort() always throws exception
return;
}
}
catch (Exception exc)
{
Device.Log.Error("FetcherAsynch.FetchAsynch encountered exception", exc);
autoEvent.Set();
}
}
public static void FetchOrPull(Repository repository, Remote remote, bool pull)
{
var affectedReferences = ReferenceType.RemoteBranch | ReferenceType.Tag;
if (pull)
{
affectedReferences |= ReferenceType.LocalBranch;
}
ReferenceChange[] changes;
var state1 = RefsState.Capture(repository, affectedReferences);
using (repository.Monitor.BlockNotifications(
RepositoryNotifications.BranchChanged,
RepositoryNotifications.TagChanged))
{
try
{
if (pull)
{
var p = new PullParameters();
if (remote != null)
{
p.Repository = remote.Name;
}
repository.Accessor.Pull.Invoke(p);
}
else
{
var p = new FetchParameters();
if (remote != null)
{
p.Repository = remote.Name;
}
repository.Accessor.Fetch.Invoke(p);
}
}
finally
{
repository.Refs.Refresh(affectedReferences);
var state2 = RefsState.Capture(repository, affectedReferences);
changes = RefsDiff.Calculate(state1, state2);
if (changes != null && changes.Length != 0)
{
repository.OnUpdated();
}
}
}
if (pull)
{
repository.Remotes.OnPullCompleted(remote, changes);
}
else
{
repository.Remotes.OnFetchCompleted(remote, changes);
}
}
public static Task FetchOrPullAsync(
Repository repository, Remote remote, bool pull,
IProgress <OperationProgress> progress, CancellationToken cancellationToken)
{
var affectedReferences = ReferenceType.RemoteBranch | ReferenceType.Tag;
if (pull)
{
affectedReferences |= ReferenceType.LocalBranch;
}
var suppressedNotifications = repository.Monitor.BlockNotifications(
RepositoryNotifications.BranchChanged, RepositoryNotifications.TagChanged);
var state1 = RefsState.Capture(repository, affectedReferences);
Task task;
if (pull)
{
var p = new PullParameters();
if (remote != null)
{
p.Repository = remote.Name;
}
task = repository.Accessor.Pull.InvokeAsync(p, progress, cancellationToken);
}
else
{
var p = new FetchParameters();
if (remote != null)
{
p.Repository = remote.Name;
}
task = repository.Accessor.Fetch.InvokeAsync(p, progress, cancellationToken);
}
return(task.ContinueWith(
t =>
{
progress.Report(new OperationProgress(Resources.StrRefreshingReferences.AddEllipsis()));
repository.Refs.Refresh(affectedReferences);
var state2 = RefsState.Capture(repository, affectedReferences);
var changes = RefsDiff.Calculate(state1, state2);
suppressedNotifications.Dispose();
if (changes != null && changes.Length != 0)
{
repository.OnUpdated();
}
TaskUtility.PropagateFaultedStates(t);
if (pull)
{
repository.Remotes.OnPullCompleted(remote, changes);
}
else
{
repository.Remotes.OnFetchCompleted(remote, changes);
}
}));
}
// this injection is fine since the design hides this behind internal
internal PagingFetchBuilder(BasicRepository repository, FetchParameters <TModel> fetchParameters)
{
if (fetchParameters == null)
{
throw new System.ArgumentNullException(nameof(fetchParameters));
}
this.fetchParameters = new FetchPagingParameters <TModel>(fetchParameters);
this.repository = repository;
}
internal static IQueryable <TModel> PerformFiltering <TModel>(this FetchParameters <TModel> target, IQueryable <TModel> queriedItems) where TModel : class
{
if (target.FilteringRules != null)
{
foreach (var filteringRule in target.FilteringRules.Where(x => x != null))
{
queriedItems = queriedItems.Where(filteringRule);
}
}
return(queriedItems);
}
protected void lnkbtnGoogleClick(object sender, EventArgs e)
{
var oAuthRequest = new OAuthRequest {
Provider = OAuthRequest.Providers.Google
};
var parameters = new FetchParameters();
parameters.OpenidUserInformation.Add(RequestParameters.AxSchemaParams.Contact.email);
parameters.OpenidUserInformation.Add(RequestParameters.AxSchemaParams.NamePerson.First);
parameters.OpenidUserInformation.Add(RequestParameters.AxSchemaParams.NamePerson.Last);
oAuthRequest.CreateRequest(parameters);
}
/// <summary>
/// Fetch file for created session.
/// </summary>
/// <param name="sessionId">Session identifier.</param>
/// <param name="templateCode">Element's template code.</param>
/// <param name="fetchParameters">Fetch parameters.</param>
/// <exception cref="InvalidTemplateException">Specified template code does not refer to binary element.</exception>
/// <exception cref="InvalidFetchUrlException">Fetch URL is invalid.</exception>
/// <exception cref="MissingFilenameException">Filename is not specified.</exception>
/// <exception cref="ObjectNotFoundException">Session or template has not been found.</exception>
/// <exception cref="SessionExpiredException">Specified session is expired.</exception>
/// <exception cref="S3Exception">Error making request to S3.</exception>
/// <exception cref="InvalidBinaryException">Binary does not meet template's constraints.</exception>
/// <exception cref="FetchFailedException">Fetch request failed.</exception>
/// <returns>Fetched file key.</returns>
public async Task <string> FetchFile(Guid sessionId, int templateCode, FetchParameters fetchParameters)
{
if (!TryCreateUri(fetchParameters, out var fetchUri))
{
throw new InvalidFetchUrlException(
$"Fetch URI must be a valid absolute URI with '{Uri.UriSchemeHttp}' or '{Uri.UriSchemeHttps}' scheme");
}
MultipartUploadSession uploadSession = null;
var(sessionDescriptor, _, expiresAt) = await _sessionStorageReader.GetSessionDescriptor(sessionId); // Firstly ensure that specified session exists
try
{
var(stream, mediaType) = await _fetchClient.FetchAsync(fetchUri);
var fileMetadata = new GenericUploadedFileMetadata(fetchParameters.FileName, mediaType, stream.Length);
uploadSession = await InitiateMultipartUploadInternal(sessionId, templateCode, fileMetadata, sessionDescriptor, expiresAt);
await UploadFilePart(uploadSession, stream, templateCode);
var fetchedFileKey = await CompleteMultipartUpload(uploadSession);
return(fetchedFileKey);
}
catch (FetchResponseTooLargeException ex)
{
throw new InvalidBinaryException(templateCode, new BinaryTooLargeError(ex.ContentLength));
}
catch (FetchRequestException ex)
{
throw new FetchFailedException($"Fetch request failed with status code {ex.StatusCode} and content: {ex.Message}");
}
catch (HttpRequestException ex)
{
throw new FetchFailedException($"Fetch request failed: {ex.Message}");
}
catch (TimeoutRejectedException)
{
throw new FetchFailedException("Fetch request failed: request timeout exceeded");
}
catch (FetchResponseContentTypeInvalidException ex)
{
throw new FetchFailedException($"Fetch request failed: {ex.Message}");
}
finally
{
if (uploadSession != null)
{
await AbortMultipartUpload(uploadSession);
}
}
}
internal static IQueryable <TModel> PerformSorting <TModel>(this FetchParameters <TModel> target, IQueryable <TModel> queriedItems) where TModel : class
{
if (target.HasSorting())
{
var rules = target.SortingRules.Where(x => x != null);
if (!rules.Any())
{
return(queriedItems); // sanity check
}
foreach (var sortingRule in rules)
{
queriedItems = queriedItems.OrderBy(sortingRule);
}
}
return(queriedItems);
}
public async Task <ActionResult> FetchFile(
Guid sessionId,
int templateCode,
[FromBody] FetchParameters fetchParameters)
{
if (fetchParameters == null)
{
return(BadRequest($"Request body with {nameof(fetchParameters)} must be specified"));
}
try
{
var fetchedFileKey = await _sessionManagementService.FetchFile(sessionId, templateCode, fetchParameters);
return(Created(_cdnOptions.AsRawUri(fetchedFileKey), new FetchedFileValue(fetchedFileKey)));
}
catch (MissingFilenameException ex)
{
return(BadRequest(ex.Message));
}
catch (InvalidTemplateException ex)
{
return(BadRequest(ex.Message));
}
catch (InvalidFetchUrlException ex)
{
return(BadRequest(ex.Message));
}
catch (ObjectNotFoundException)
{
return(NotFound());
}
catch (SessionExpiredException ex)
{
return(Gone(ex.ExpiredAt));
}
catch (FetchFailedException ex)
{
return(FailedDependency(ex.Message));
}
catch (InvalidBinaryException ex)
{
return(Unprocessable(GenerateErrorJsonResult(ex)));
}
}
private void FetchAsynch(Object parameters)
{
FetchParameters fetchParameters = (FetchParameters)parameters;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(fetchParameters.Uri);
request.Method = "GET";
//request.Proxy = null;
#if !SILVERLIGHT && !MONO
request.AutomaticDecompression = DecompressionMethods.GZip;
#endif
if (fetchParameters.Headers != null && fetchParameters.Headers.Count() > 0)
{
foreach (string key in fetchParameters.Headers.Keys)
{
request.Headers[key] = fetchParameters.Headers[key];
}
}
RequestState state = new RequestState()
{
Request = request,
AbsoluteUri = fetchParameters.Uri,
FileName = fetchParameters.FileName
};
// Start the asynchronous request.
IAsyncResult result = request.BeginGetResponse(new AsyncCallback(ResponseCallback), state);
if (!allDone.WaitOne(DefaultTimeout))
{
OnError(state);
return;
}
}
/// <summary>
/// Synchronous Wrapper method around FetchAsynch() method
/// </summary>
/// <param name="cacheIndex"></param>
/// <param name="cacheIndexItem"></param>
public NetworkResponse Fetch( string uri, string filename, Dictionary<string, string> headers )
{
PostNetworkResponse = new NetworkResponse();
FetchParameters fetchParameters = new FetchParameters()
{
Uri = uri,
Headers = headers,
FileName = filename
};
DateTime dtMetric = DateTime.UtcNow;
// set callback and error handler
OnDownloadComplete += new NetworkingEventHandler( FetcherAsynch_OnDownloadComplete );
OnError += new NetworkingErrorHandler( FetcherAsynch_OnError );
System.Threading.ThreadPool.QueueUserWorkItem( parameters =>
{
try
{
FetchAsynch( parameters );
}
//catch ( Exception e )
//{
// // You could react or save the exception to an 'outside' variable
// // threadExc = e;
//}
finally
{
autoEvent.Set(); // if you're firing and not forgetting ;)
}
}, fetchParameters );
// WaitOne returns true if autoEvent were signaled (i.e. process completed before timeout expired)
// WaitOne returns false it the timeout expired before the process completed.
if ( !autoEvent.WaitOne( DefaultTimeout ) )
{
string message = "FetcherAsynch call to FetchAsynch timed out. uri " + fetchParameters.Uri;
MXDevice.Log.Error( message );
MXDevice.Log.Debug( string.Format( "FetchAsynch timed out: Uri: {0} Time: {1} milliseconds ", uri, DateTime.UtcNow.Subtract( dtMetric ).TotalMilliseconds ) );
NetworkResponse networkResponse = new NetworkResponse()
{
Message = message,
URI = fetchParameters.Uri,
StatusCode = HttpStatusCode.RequestTimeout,
ResponseString = string.Empty,
Expiration = DateTime.MinValue.ToUniversalTime(),
};
MXDevice.PostNetworkResponse( networkResponse );
return networkResponse;
}
//if ( threadExc != null )
//{
// throw threadExc;
//}
MXDevice.Log.Debug( string.Format( "FetchAsynch Completed: Uri: {0} Time: {1} milliseconds Size: {2} ", uri, DateTime.UtcNow.Subtract( dtMetric ).TotalMilliseconds, ( PostNetworkResponse.ResponseBytes != null ? PostNetworkResponse.ResponseBytes.Length : -1 ) ) );
return PostNetworkResponse;
}
internal static bool HasSorting <TModel>(this FetchParameters <TModel> target) where TModel : class
{
return(target.SortingRules != null && target.SortingRules.Any(x => x != null));
}
/// <summary>
/// Fetches the specified URI.
/// </summary>
/// <param name="uri">The URI of the resource to fetch.</param>
/// <param name="filename">The name of the file to be fetched.</param>
/// <param name="headers">The headers to be added to the request.</param>
/// <param name="timeout">The request timeout value in milliseconds.</param>
public NetworkResponse Fetch(string uri, string filename, IDictionary <string, string> headers, int timeout)
{
PostNetworkResponse = new NetworkResponse();
FetchParameters fetchParameters = new FetchParameters()
{
Uri = uri,
Headers = headers,
FileName = filename,
Timeout = timeout
};
DateTime dtMetric = DateTime.UtcNow;
// set callback and error handler
OnDownloadComplete -= FetcherAsynch_OnDownloadComplete;
OnDownloadComplete += FetcherAsynch_OnDownloadComplete;
OnError -= FetcherAsynch_OnError;
OnError += FetcherAsynch_OnError;
Exception threadExc = null;
Device.Thread.QueueWorker(parameters =>
{
try
{
FetchAsynch(parameters);
}
catch (Exception e)
{
Device.Log.Info("This exception occurred in FetchingAsynch:", e);
// You could react or save the exception to an 'outside' variable 6`
threadExc = e;
}
finally
{
autoEvent.Set(); // if you're firing and not forgetting ;)
}
}, fetchParameters);
// WaitOne returns true if autoEvent were signaled (i.e. process completed before timeout expired)
// WaitOne returns false it the timeout expired before the process completed.
if (!autoEvent.WaitOne(timeout))
{
string message = "FetcherAsynch call to FetchAsynch timed out. uri " + fetchParameters.Uri;
Device.Log.Metric("FetchAsynch timed out: Uri: {0} Time: {1:F0} milliseconds ", uri, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds);
NetworkResponse networkResponse = new NetworkResponse()
{
Message = message,
URI = fetchParameters.Uri,
StatusCode = HttpStatusCode.RequestTimeout,
WebExceptionStatusCode = WebExceptionStatus.Timeout,
ResponseString = string.Empty,
Expiration = DateTime.MinValue.ToUniversalTime(),
AttemptToRefresh = DateTime.MinValue.ToUniversalTime(),
Downloaded = DateTime.UtcNow,
Exception = threadExc
};
Device.PostNetworkResponse(networkResponse);
return(networkResponse);
}
else if (threadExc != null)
{
PostNetworkResponse.Exception = threadExc;
PostNetworkResponse.Message = "FetchAsync threw an exception";
PostNetworkResponse.StatusCode = (HttpStatusCode)(-1);
}
Device.Log.Metric(string.Format("FetchAsynch Completed: Uri: {0} Time: {1:F0} milliseconds Size: {2} ", uri, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds, (PostNetworkResponse.ResponseBytes != null ? PostNetworkResponse.ResponseBytes.Length : -1)));
return(PostNetworkResponse);
}
public FetchOneParameters(FetchParameters <TModel> fetchParameters) : base(fetchParameters)
{
NoTracking = false;
}
private static bool TryCreateUri(FetchParameters fetchParameters, out Uri fetchUri) => Uri.TryCreate(fetchParameters.Url, UriKind.Absolute, out fetchUri) && fetchUri.IsWellFormedOriginalString() && (fetchUri.Scheme == Uri.UriSchemeHttp || fetchUri.Scheme == Uri.UriSchemeHttps);
/// <summary>
/// Fetches the specified cache index item from the cache index.
/// </summary>
/// <param name="cacheIndex">Index of the cache.</param>
/// <param name="cacheIndexItem">The cache index item.</param>
/// <param name="args">NetworkResourceArguments for the request</param>
/// <returns></returns>
public NetworkResponse Fetch(CacheIndex cacheIndex, CacheIndexItem cacheIndexItem, NetworkResourceArguments args) //IDictionary<string, string> headers, int timeoutMilliseconds)
{
PostNetworkResponse = new NetworkResponse();
var fetchParameters = new FetchParameters
{
CacheIndex = cacheIndex,
CacheIndexItem = cacheIndexItem,
Headers = args.Headers,
DefaultExpiration = args.Expiration,
};
int timeoutMilliseconds = args.TimeoutMilliseconds;
DateTime dtMetric = DateTime.UtcNow;
// set callback and error handler
OnDownloadComplete += CacheFetcher_OnDownloadComplete;
OnError += CacheFetcher_OnError;
Exception threadExc = null;
Device.Thread.QueueWorker(parameters =>
{
try
{
FetchAsynch(parameters, timeoutMilliseconds);
}
catch (Exception e)
{
// You could react or save the exception to an 'outside' variable
threadExc = e;
}
finally
{
_autoEvent.Set(); // if you're firing and not forgetting ;)
}
}, fetchParameters);
// WaitOne returns true if autoEvent were signaled (i.e. process completed before timeout expired)
// WaitOne returns false it the timeout expired before the process completed.
if (!_autoEvent.WaitOne(timeoutMilliseconds))
{
string message = "CacheFetcher call to FetchAsynch timed out. uri " + fetchParameters.CacheIndexItem.RelativeUri;
Device.Log.Metric(string.Format("CacheFetcher timed out: Uri: {0} Time: {1:F0} milliseconds ", fetchParameters.CacheIndexItem.RelativeUri, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds));
var networkResponse = new NetworkResponse
{
Message = message,
URI = fetchParameters.CacheIndex.GetAbsouteUri(fetchParameters.CacheIndexItem),
StatusCode = HttpStatusCode.RequestTimeout,
WebExceptionStatusCode = WebExceptionStatus.RequestCanceled, // not using ConnectFailure because connection may have succeeded
ResponseString = string.Empty,
Expiration = DateTime.MinValue.ToUniversalTime(),
Downloaded = DateTime.MinValue.ToUniversalTime(),
AttemptToRefresh = DateTime.MinValue.ToUniversalTime(),
Exception = threadExc,
};
return(networkResponse);
}
else if (threadExc != null)
{
PostNetworkResponse.Exception = threadExc;
PostNetworkResponse.Message = "CacheFetcher.FetchAsync threw an exception";
PostNetworkResponse.StatusCode = (HttpStatusCode)(-1);
}
Device.Log.Metric(string.Format("CacheFetcher Completed: Uri: {0} Time: {1:F0} milliseconds ", PostNetworkResponse.URI, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds));
return(PostNetworkResponse);
}
internal Task <List <TModel> > FetchAsync <TModel>(FetchParameters <TModel> fetchParameters)
where TModel : class
{
return(FormFetchQuery(fetchParameters).ToListAsync());
}
internal List <TModel> Fetch <TModel>(FetchParameters <TModel> fetchParameters)
where TModel : class
{
return(FormFetchQuery(fetchParameters).ToList());
}
/// <summary>
/// Synchronous Wrapper method around FetchAsynch() method
/// </summary>
/// <param name="cacheIndex"></param>
/// <param name="cacheIndexItem"></param>
public NetworkResponse Fetch(string uri, string filename, Dictionary <string, string> headers)
{
PostNetworkResponse = new NetworkResponse();
FetchParameters fetchParameters = new FetchParameters()
{
Uri = uri,
Headers = headers,
FileName = filename
};
DateTime dtMetric = DateTime.UtcNow;
// set callback and error handler
OnDownloadComplete += new NetworkingEventHandler(FetcherAsynch_OnDownloadComplete);
OnError += new NetworkingErrorHandler(FetcherAsynch_OnError);
System.Threading.ThreadPool.QueueUserWorkItem(parameters =>
{
try
{
FetchAsynch(parameters);
}
//catch ( Exception e )
//{
// // You could react or save the exception to an 'outside' variable
// // threadExc = e;
//}
finally
{
autoEvent.Set(); // if you're firing and not forgetting ;)
}
}, fetchParameters);
// WaitOne returns true if autoEvent were signaled (i.e. process completed before timeout expired)
// WaitOne returns false it the timeout expired before the process completed.
if (!autoEvent.WaitOne(DefaultTimeout))
{
string message = "FetcherAsynch call to FetchAsynch timed out. uri " + fetchParameters.Uri;
MXDevice.Log.Error(message);
MXDevice.Log.Debug(string.Format("FetchAsynch timed out: Uri: {0} Time: {1} milliseconds ", uri, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds));
NetworkResponse networkResponse = new NetworkResponse()
{
Message = message,
URI = fetchParameters.Uri,
StatusCode = HttpStatusCode.RequestTimeout,
ResponseString = string.Empty,
Expiration = DateTime.MinValue.ToUniversalTime(),
};
MXDevice.PostNetworkResponse(networkResponse);
return(networkResponse);
}
//if ( threadExc != null )
//{
// throw threadExc;
//}
MXDevice.Log.Debug(string.Format("FetchAsynch Completed: Uri: {0} Time: {1} milliseconds Size: {2} ", uri, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds, (PostNetworkResponse.ResponseBytes != null ? PostNetworkResponse.ResponseBytes.Length : -1)));
return(PostNetworkResponse);
}
private static void InsertFetchParameters(FetchParameters parameters, IList<ICommandArgument> args)
{
if(parameters.All)
{
args.Add(FetchCommand.All());
}
if(parameters.Append)
{
args.Add(FetchCommand.Append());
}
if(parameters.Prune)
{
args.Add(FetchCommand.Prune());
}
if(parameters.Depth != 0)
{
args.Add(FetchCommand.Depth(parameters.Depth));
}
switch(parameters.TagFetchMode)
{
case TagFetchMode.Default:
break;
case TagFetchMode.AllTags:
args.Add(FetchCommand.Tags());
break;
case TagFetchMode.NoTags:
args.Add(FetchCommand.NoTags());
break;
}
if(parameters.KeepDownloadedPack)
{
args.Add(FetchCommand.Keep());
}
if(parameters.Force)
{
args.Add(FetchCommand.Force());
}
if(!string.IsNullOrWhiteSpace(parameters.UploadPack))
{
args.Add(FetchCommand.UploadPack(parameters.UploadPack));
}
if(!string.IsNullOrWhiteSpace(parameters.Repository))
{
args.Add(new CommandParameter(parameters.Repository));
}
}
public Command GetFetchCommand(FetchParameters parameters, bool isAsync)
{
Assert.IsNotNull(parameters);
var args = new List<ICommandArgument>(10);
InsertFetchParameters(parameters, args);
if(isAsync && GitFeatures.ProgressFlag.IsAvailableFor(_gitCLI))
{
args.Add(FetchCommand.Progress());
}
return new FetchCommand(args);
}
private void FetchAsynch(Object parameters)
{
FetchParameters fetchParameters = (FetchParameters)parameters;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(fetchParameters.Uri);
request.Method = "GET";
if (fetchParameters.Headers != null && fetchParameters.Headers.Any())
{
foreach (string key in fetchParameters.Headers.Keys)
{
var keyValue = key.ToLower();
if (keyValue == "accept")
{
request.Accept = fetchParameters.Headers[key];
}
else if (keyValue == "content-type")
{
request.ContentType = fetchParameters.Headers[key];
}
else if (keyValue == "host")
{
request.Host = fetchParameters.Headers[key];
}
else if (keyValue == "accept-encoding")
{
string encodingValue = fetchParameters.Headers[key];
if (encodingValue.ToLower().Contains("gzip"))
{
request.AutomaticDecompression = DecompressionMethods.GZip;
}
}
else
{
request.Headers[key] = fetchParameters.Headers[key];
}
}
}
FetcherAsynch.RequestState state = new FetcherAsynch.RequestState()
{
Request = request,
AbsoluteUri = fetchParameters.Uri,
FileName = fetchParameters.FileName,
Downloaded = DateTime.UtcNow
};
try
{
// Start the asynchronous request.
IAsyncResult result = request.BeginGetResponse(new AsyncCallback(ResponseCallback), state);
#if NETCF
if (!allDone.WaitOne(fetchParameters.Timeout, false))
#else
if (!allDone.WaitOne(fetchParameters.Timeout))
#endif
{
try { request.Abort(); } catch (Exception) { } // .Abort() always throws exception
return;
}
}
catch (Exception exc)
{
Device.Log.Error("FetcherAsynch.FetchAsynch encountered exception", exc);
autoEvent.Set();
}
}
