public NetworkResponse Fetch(CacheIndex cacheIndex, CacheIndexItem cacheIndexItem, int timeoutMilliseconds)
{
NetworkResourceArguments args = new NetworkResourceArguments()
{
Headers = Device.RequestInjectionHeaders,
TimeoutMilliseconds = timeoutMilliseconds,
};
return(Fetch(cacheIndex, cacheIndexItem, args));
}
/// <summary>
/// Enqueues the specified cache index delegate.
/// </summary>
/// <param name="cacheIndexDelegate">The cache index delegate.</param>
/// <param name="cacheIndexItem">The cache index item.</param>
public void Enqueue(CacheIndexDelegate cacheIndexDelegate, CacheIndexItem cacheIndexItem)
{
CacheIndexDelegateCall cacheIndexDelegateCall = new CacheIndexDelegateCall()
{
Delegate = cacheIndexDelegate,
Item = cacheIndexItem
};
base.Enqueue(cacheIndexDelegateCall);
TriggerTimer();
}
/// <summary>
/// Extracts a resoure into the NRL cache files and applies metadata.
/// </summary>
/// <param name="uri">The URI of the resource.</param>
/// <param name="metadataFileName">Name of the metadata file.</param>
/// <param name="headers">The headers for the request.</param>
/// <param name="timeout">The timeout for the requst in milliseconds.</param>
/// <param name="postObject">The object to post.</param>
/// <param name="serializationFormat">The serialization format.</param>
/// <returns></returns>
public NetworkResponse Extract(string uri, string metadataFileName, IDictionary <string, string> headers, int timeout,
object postObject, SerializationFormat serializationFormat)
{
// if cache is not supported then don't bother extracting.
if (Device.NetworkGetMethod == MonoCross.Utilities.Network.NetworkGetMethod.NoCache)
{
Device.Log.Debug("Cache is not supported, Zip file extraction request ignored.");
return(new NetworkResponse()
{
StatusCode = HttpStatusCode.OK,
Message = "Cache is not supported, Zip file extraction request ignored.",
URI = uri,
Verb = "GET"
});
}
// validate parameter
if (string.IsNullOrEmpty(uri))
{
throw new ArgumentNullException("uri");
}
if (!Uri.IsWellFormedUriString(uri, UriKind.Absolute))
{
throw new ArgumentNullException("Cache Zip location is not a valid Absolute URI " + uri, "uri");
}
DateTime dtMetric = DateTime.UtcNow;
CacheIndex cacheIndex = CacheIndexMap.GetFromUri(uri);
CacheIndexItem zipCacheIndexItem = cacheIndex.Get(uri);
zipCacheIndexItem.PreFetch = false;
NetworkResponse networkResponse = null;
bool idleQueueEnabled = Device.Thread.IdleQueueEnabled;
try
{
// temporarily deactivate idle queue thread.
if (idleQueueEnabled)
{
Device.Thread.IdleQueueEnabled = false;
}
// download zip file from uri
string zipFileName = cacheIndex.GetCachePath(zipCacheIndexItem);
networkResponse = DownloadZipFile(uri, zipFileName, headers, timeout, postObject); //, serializationFormat );
if (networkResponse.StatusCode != HttpStatusCode.OK)
{
return(networkResponse);
}
string cachePath = cacheIndex.CachePath.AppendPath(cacheIndex.BaseUriPath);
// extract zip file into NRL cache
networkResponse.Message = "Extract Zip File";
ExtractZipFile(zipFileName, cachePath);
// process metadata for extracted files.
networkResponse.Message = "Import Metadata";
metadataFileName = cacheIndex.CachePath.AppendPath(cacheIndex.BaseUriPath).AppendPath(metadataFileName);
ImportMetadata(metadataFileName, cacheIndex);
Device.Log.Metric(string.Format("Extract and process zip file: file: {0} Time: {1} milliseconds", zipFileName, DateTime.UtcNow.Subtract(dtMetric).TotalMilliseconds));
networkResponse.Message = "Complete";
}
//catch ( WebException ex )
//{
// if ( ex.Response != null )
// {
// networkResponse.StatusCode = ( (HttpWebResponse) ex.Response ).StatusCode;
// ex.Data["StatusDescription"] = ( (HttpWebResponse) ex.Response ).StatusDescription;
// }
// else
// {
// networkResponse.StatusCode = (HttpStatusCode) ( -2 );
// }
// networkResponse.WebExceptionStatusCode = ex.Status;
// Device.Log.Error( ex );
// networkResponse.Exception = ex;
//}
catch (Exception exc)
{
Device.Log.Error(exc);
networkResponse.Exception = exc;
networkResponse.StatusCode = (HttpStatusCode)(-1);
}
finally
{
// remove zip file after processing is complete. perhaps in a finally block
if (cacheIndex != null && zipCacheIndexItem != null)
{
cacheIndex.RemoveCurrentCache(zipCacheIndexItem);
// cacheIndex.Remove( zipCacheIndexItem );
}
// reactivate queue thread if it was previously active.
if (idleQueueEnabled)
{
Device.Thread.IdleQueueEnabled = true;
}
// Serialize Cache Index due to changes.
CacheIndex.SerializeCacheIndex(cacheIndex);
}
return(networkResponse);
}
/// <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);
}
