public long BenchmarkGetTimelineData(User user, RetrievalMethod method = RetrievalMethod.Id)
{
var timer = Stopwatch.StartNew();
GetTimelineDataInternal(user, method);
return(timer.ElapsedMilliseconds);
}
/// <summary>
/// Calculates a <see cref="ManifestDigest"/> for a retrieval method. Sets missing properties in the process.
/// </summary>
/// <param name="retrievalMethod">The retrieval method.</param>
/// <param name="executor">Used to modify properties in an undoable fashion.</param>
/// <param name="handler">A callback object used when the the user is to be informed about progress.</param>
/// <param name="format">The manifest format. Leave <c>null</c> for default.</param>
/// <returns>The generated digest.</returns>
/// <exception cref="OperationCanceledException">The user canceled the task.</exception>
/// <exception cref="WebException">A file could not be downloaded from the internet.</exception>
public static ManifestDigest CalculateDigest(this RetrievalMethod retrievalMethod, ICommandExecutor executor, ITaskHandler handler, ManifestFormat?format = null)
{
#region Sanity checks
if (retrievalMethod == null)
{
throw new ArgumentNullException(nameof(retrievalMethod));
}
if (executor == null)
{
throw new ArgumentNullException(nameof(executor));
}
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
#endregion
var builder = new ManifestBuilder(format ?? ManifestFormat.Sha256New);
builder.Add(retrievalMethod, executor, handler);
var digest = new ManifestDigest(builder.Manifest.CalculateDigest());
if (digest.PartialEquals(ManifestDigest.Empty))
{
Log.Warn(Resources.EmptyImplementation);
}
return(digest);
}
public static Implementation Build([NotNull] RetrievalMethod retrievalMethod, [NotNull] ITaskHandler handler, bool keepDownloads = false)
{
#region Sanity checks
if (retrievalMethod == null)
{
throw new ArgumentNullException("retrievalMethod");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
#endregion
var implementationDir = retrievalMethod.DownloadAndApply(handler);
try
{
var digest = GenerateDigest(implementationDir, handler, keepDownloads);
return(new Implementation {
ID = @"sha1new=" + digest.Sha1New, ManifestDigest = digest, RetrievalMethods = { retrievalMethod }
});
}
finally
{
implementationDir.Dispose();
}
}
/// <summary>
/// Creates a new <see cref="Implementation"/> by completing a <see cref="RetrievalMethod"/> and calculating the resulting <see cref="ManifestDigest"/>.
/// </summary>
/// <param name="retrievalMethod">The <see cref="RetrievalMethod"/> to use.</param>
/// <param name="handler">A callback object used when the the user is to be informed about progress.</param>
/// <param name="keepDownloads">Used to retain downloaded implementations; can be <c>null</c>.</param>
/// <returns>A newly created <see cref="Implementation"/> containing one <see cref="Archive"/>.</returns>
/// <exception cref="OperationCanceledException">The user canceled the task.</exception>
/// <exception cref="UriFormatException"><see cref="DownloadRetrievalMethod.Href"/> inside <paramref name="retrievalMethod"/> is a relative URI that cannot be resolved.</exception>
/// <exception cref="IOException">There was a problem extracting the archive.</exception>
/// <exception cref="WebException">There was a problem downloading the archive.</exception>
/// <exception cref="UnauthorizedAccessException">Write access to temporary files was not permitted.</exception>
/// <exception cref="NotSupportedException">A <see cref="Archive.MimeType"/> is not supported.</exception>
public static Implementation Build(RetrievalMethod retrievalMethod, ITaskHandler handler, IImplementationStore?keepDownloads = null)
{
#region Sanity checks
if (retrievalMethod == null)
{
throw new ArgumentNullException(nameof(retrievalMethod));
}
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
#endregion
var implementationDir = retrievalMethod.DownloadAndApply(handler);
try
{
var digest = new Implementation {
RetrievalMethods = { retrievalMethod }
};
digest.UpdateDigest(implementationDir, handler, new SimpleCommandExecutor(), keepDownloads);
return(digest);
}
finally
{
implementationDir.Dispose();
}
}
/// <summary>
/// Executes a specific <see cref="RetrievalMethod"/>.
/// </summary>
/// <param name="retrievalMethod">The retrieval method to execute.</param>
/// <param name="manifestDigest">The digest the result of the retrieval method should produce.</param>
/// <exception cref="OperationCanceledException">A download or IO task was canceled from another thread.</exception>
/// <exception cref="WebException">A file could not be downloaded from the internet.</exception>
/// <exception cref="NotSupportedException">A file format, protocol, etc. is unknown or not supported.</exception>
/// <exception cref="IOException">A downloaded file could not be written to the disk or extracted.</exception>
/// <exception cref="UnauthorizedAccessException">Write access to <see cref="IImplementationStore"/> is not permitted.</exception>
/// <exception cref="DigestMismatchException">An <see cref="Implementation"/>'s <see cref="Archive"/>s don't match the associated <see cref="ManifestDigest"/>.</exception>
private void Retrieve(RetrievalMethod retrievalMethod, ManifestDigest manifestDigest)
{
if (retrievalMethod is ExternalRetrievalMethod externalRetrievalMethod)
{
RunNative(externalRetrievalMethod);
return;
}
// Treat single steps as a Recipes for easier handling
var recipe = retrievalMethod as Recipe ?? new Recipe {
Steps = { (IRecipeStep)retrievalMethod }
};
try
{
// Enable Recipe steps to call back to Fetcher
using (FetchHandle.Register(impl => Fetch(impl, tag: manifestDigest) ?? throw new ImplementationNotFoundException(manifestDigest)))
Cook(recipe, manifestDigest);
}
#region Error handling
catch (ImplementationAlreadyInStoreException)
{}
catch (DigestMismatchException)
{
Log.Error("Damaged download: " + retrievalMethod);
throw;
}
#endregion
}
/// <summary>
/// Executes a specific <see cref="RetrievalMethod"/>.
/// </summary>
/// <param name="retrievalMethod">The retrieval method to execute.</param>
/// <param name="manifestDigest">The digest the result of the retrieval method should produce.</param>
/// <exception cref="OperationCanceledException">A download or IO task was canceled from another thread.</exception>
/// <exception cref="WebException">A file could not be downloaded from the internet.</exception>
/// <exception cref="NotSupportedException">A file format, protocal, etc. is unknown or not supported.</exception>
/// <exception cref="IOException">A downloaded file could not be written to the disk or extracted.</exception>
/// <exception cref="UnauthorizedAccessException">Write access to <see cref="IStore"/> is not permitted.</exception>
/// <exception cref="DigestMismatchException">An <see cref="Implementation"/>'s <see cref="Archive"/>s don't match the associated <see cref="ManifestDigest"/>.</exception>
private void Retrieve([NotNull] RetrievalMethod retrievalMethod, ManifestDigest manifestDigest)
{
var externalRetrievalMethod = retrievalMethod as ExternalRetrievalMethod;
if (externalRetrievalMethod != null)
{
RunNative(externalRetrievalMethod);
return;
}
// Treat single steps as a Recipes for easier handling
var recipe = retrievalMethod as Recipe ?? new Recipe {
Steps = { (IRecipeStep)retrievalMethod }
};
try
{
Cook(recipe, manifestDigest);
}
#region Error handling
catch (ImplementationAlreadyInStoreException)
{}
catch (DigestMismatchException ex)
{
// Wrap exception to add context information
throw new DigestMismatchException("Damaged download: " + retrievalMethod, ex);
}
#endregion
}
public static TemporaryDirectory DownloadAndApply([NotNull] this RetrievalMethod retrievalMethod, [NotNull] ITaskHandler handler, [CanBeNull] ICommandExecutor executor = null)
{
#region Sanity checks
if (retrievalMethod == null)
{
throw new ArgumentNullException("retrievalMethod");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
#endregion
var download = retrievalMethod as DownloadRetrievalMethod;
if (download != null)
{
return(download.DownloadAndApply(handler, executor));
}
var recipe = retrievalMethod as Recipe;
if (recipe != null)
{
return(recipe.DownloadAndApply(handler, executor));
}
throw new NotSupportedException(Resources.UnknownRetrievalMethodType);
}
public PuzzleRetriever(string defaultFile, int level, RetrievalMethod mode, Size generationSize, int maxColor)
{
this.mode = mode;
this.level = level - 1; // the -1 is because .Next() immediately increments level
puzzlegen = new PuzzleGenerator();
puzzleparser = new FileParser(defaultFile);
genSize = generationSize;
this.maxColor = maxColor;
//puzzlegen.QueueLevels(levelsToGenerateAtOnce, genSize.Width, genSize.Height, maxColor);
}
public T Get(RetrievalMethod rm)
{
switch (rm)
{
case RetrievalMethod.Basic:
return(GetBasic());
case RetrievalMethod.Existing:
return(GetExisting());
}
}
public TimelineData GetTimelineData(User user, RetrievalMethod method = RetrievalMethod.Id)
{
var cacheKey = CacheKey(user, "TimelineData");
if (!_memoryCache.TryGetValue(cacheKey, out TimelineData timelineData))
{
var options = new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromSeconds(300));
timelineData = GetTimelineDataInternal(user, method);
_memoryCache.Set(cacheKey, timelineData, options);
}
return(timelineData);
}
/// <summary>
/// Downloads and applies a <see cref="RetrievalMethod"/> and adds missing properties.
/// </summary>
/// <param name="retrievalMethod">The <see cref="RetrievalMethod"/> to be downloaded.</param>
/// <param name="handler">A callback object used when the the user is to be informed about progress.</param>
/// <param name="executor">Used to apply properties in an undoable fashion.</param>
/// <returns>A temporary directory containing the extracted content.</returns>
/// <exception cref="OperationCanceledException">The user canceled the task.</exception>
/// <exception cref="UriFormatException"><see cref="DownloadRetrievalMethod.Href"/> inside <paramref name="retrievalMethod"/> is a relative URI that cannot be resolved.</exception>
/// <exception cref="IOException">There is a problem access a temporary file.</exception>
/// <exception cref="WebException">A file could not be downloaded from the internet.</exception>
/// <exception cref="UnauthorizedAccessException">Read or write access to a temporary file is not permitted.</exception>
/// <exception cref="NotSupportedException">A <see cref="Archive.MimeType"/> is not supported.</exception>
public static TemporaryDirectory DownloadAndApply(this RetrievalMethod retrievalMethod, ITaskHandler handler, ICommandExecutor?executor = null)
{
#region Sanity checks
if (retrievalMethod == null)
{
throw new ArgumentNullException(nameof(retrievalMethod));
}
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
#endregion
return(retrievalMethod switch
{
DownloadRetrievalMethod download => download.DownloadAndApply(handler, executor),
Recipe recipe => recipe.DownloadAndApply(handler, executor),
_ => throw new NotSupportedException(Resources.UnknownRetrievalMethodType)
});
private TimelineData GetTimelineDataInternal(User user, RetrievalMethod method)
{
#if !DEBUG
if (method != RetrievalMethod.Id)
{
throw new InvalidEnumArgumentException($"Only retrieval by id can be used in a non-debug environment");
}
#endif
switch (method)
{
case RetrievalMethod.Id: return(LoadTimelineDataByIdAggregation(user));
case RetrievalMethod.Include: return(LoadTimelineDataByInclude(user));
case RetrievalMethod.Load: return(LoadTimelineDataByExplicitLoad(user));
case RetrievalMethod.Predicate: return(LoadTimelineDataByPredicateAggregation(user));
}
throw new InvalidEnumArgumentException($"Method does not support provided Enum {method}");
}
/// <summary>
/// Executes a specific <see cref="RetrievalMethod"/>.
/// </summary>
/// <param name="retrievalMethod">The retrieval method to execute.</param>
/// <param name="manifestDigest">The digest the result of the retrieval method should produce.</param>
private void Retrieve(RetrievalMethod retrievalMethod, ManifestDigest manifestDigest)
{
var externalRetrievalMethod = retrievalMethod as ExternalRetrievalMethod;
if (externalRetrievalMethod != null)
{
RunNative(externalRetrievalMethod);
return;
}
// Treat single steps as a Recipes for easier handling
var recipe = retrievalMethod as Recipe ?? new Recipe {
Steps = { (IRecipeStep)retrievalMethod }
};
try
{
Cook(recipe, manifestDigest);
}
catch (ImplementationAlreadyInStoreException)
{}
}
public void SetMethod(RetrievalMethod m)
{
mode = m;
}
/// <summary>
/// Asserts that <paramref name="x"/> is ranked over <paramref name="y"/>.
/// </summary>
private static void AssertOver(RetrievalMethod x, RetrievalMethod y)
{
Assert.Less(RetrievalMethodRanker.Instance.Compare(x, y), 0);
Assert.Greater(RetrievalMethodRanker.Instance.Compare(y, x), 0);
}
private static bool IsDownloadSizeMissing(this RetrievalMethod retrievalMethod) => retrievalMethod is DownloadRetrievalMethod downloadRetrievalMethod && downloadRetrievalMethod.Size == 0;
private static bool IsDownloadSizeMissing(RetrievalMethod retrievalMethod)
=> retrievalMethod is DownloadRetrievalMethod
{
private static bool IsDownloadSizeMissing([NotNull] this RetrievalMethod retrievalMethod)
{
var downloadRetrievalMethod = retrievalMethod as DownloadRetrievalMethod;
return(downloadRetrievalMethod != null && downloadRetrievalMethod.Size == 0);
}
public PuzzleRetriever(string defaultFile, int level, RetrievalMethod mode, Size generationSize) : this(defaultFile, level, mode, generationSize, 10)
{
}
public PuzzleRetriever(string defaultFile, int level, RetrievalMethod mode) : this(defaultFile, level, mode, new Size(5, 5))
{
}
public PuzzleRetriever(string defaultFile, RetrievalMethod mode, int maxColor) : this(defaultFile, 0, mode, new Size(5, 5), maxColor)
{
}
public PuzzleRetriever(string defaultFile, RetrievalMethod mode) : this(defaultFile, 0, mode)
{
}
/// <summary>
/// Applies a retrieval method to the implementation. Sets missing properties in the process.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="retrievalMethod">The retrieval method.</param>
/// <param name="executor">Used to modify properties in an undoable fashion.</param>
/// <param name="handler">A callback object used when the the user needs to be informed about IO tasks.</param>
/// <exception cref="OperationCanceledException">The user canceled the task.</exception>
/// <exception cref="WebException">A file could not be downloaded from the internet.</exception>
public static void Add(this IBuilder builder, RetrievalMethod retrievalMethod, ICommandExecutor executor, ITaskHandler handler)
{
#region Sanity checks
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (retrievalMethod == null)
{
throw new ArgumentNullException(nameof(retrievalMethod));
}
if (executor == null)
{
throw new ArgumentNullException(nameof(executor));
}
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
#endregion
void Apply(IRecipeStep step)
{
switch (step)
{
case DownloadRetrievalMethod download:
builder.Add(download, executor, handler);
break;
case RemoveStep remove:
builder.Remove(remove);
break;
case RenameStep rename:
builder.Rename(rename);
break;
case CopyFromStep copyFrom:
builder.CopyFrom(copyFrom, handler);
break;
default:
throw new NotSupportedException($"Unknown recipe step: ${step}");
}
}
switch (retrievalMethod)
{
case DownloadRetrievalMethod download:
Apply(download);
break;
case Recipe recipe:
foreach (var step in recipe.Steps)
{
Apply(step);
}
break;
default:
throw new NotSupportedException($"Unknown retrieval method: ${retrievalMethod}");
}
}
/// <summary>
/// Asserts that <paramref name="x"/> is ranked over <paramref name="y"/>.
/// </summary>
private static void AssertOver(RetrievalMethod x, RetrievalMethod y)
{
RetrievalMethodRanker.Instance.Compare(x, y).Should().BeLessThan(0);
RetrievalMethodRanker.Instance.Compare(y, x).Should().BeGreaterThan(0);
}
