public LocalPackageInfo(PackageReference reference, PackageDownloadInfo downloadStatus, Dto.PackageHashes hashes, Dto.PackageMeta metadata, PackageSequenceInfo sequence)
{
LockProvider = new PackageLocks();
DownloadMeasure = new MeasureItem(MeasureType.Throughput);
UploadMeasure = new MeasureItem(MeasureType.Throughput);
Reference = reference ?? throw new ArgumentNullException(nameof(reference));
DownloadStatus = downloadStatus ?? throw new ArgumentNullException(nameof(downloadStatus));
Hashes = hashes ?? throw new ArgumentNullException(nameof(hashes));
Metadata = metadata ?? throw new ArgumentNullException(nameof(metadata));
Sequence = sequence ?? throw new ArgumentNullException(nameof(sequence));
if (!Reference.Id.Equals(DownloadStatus.PackageId))
{
throw new ArgumentException("Invalid hash.", nameof(downloadStatus));
}
if (!Reference.Id.Equals(Hashes.PackageId))
{
throw new ArgumentException("Invalid hash.", nameof(hashes));
}
if (!Reference.Id.Equals(Metadata.PackageId))
{
throw new ArgumentException("Invalid hash.", nameof(metadata));
}
if (!Metadata.PackageSize.Equals(Sequence.PackageSize))
{
throw new ArgumentException("Invalid size of package sequence.", nameof(sequence));
}
}
public void Post([FromBody] MeasureItem measureItem)
{
if (measureItem.Date == DateTime.MinValue)
{
measureItem.Date = DateTime.Now;
}
_dbContext.MeasureItems.Add(measureItem);
_dbContext.SaveChanges();
}
/// <summary>Constructor</summary>
/// <param name="unitPrice">Unit Price used</param>
/// <param name="measureItem">Measure Item used</param>
/// <param name="currencyItem">Currency Item used</param>
/// <exception cref="PriceException">Thrown when no conversion defined between currency units</exception>
/// <exception cref="MeasureException">Thrown when Measure Units have different types</exception>
public ItemPrice(IUnitPrice unitPrice, IMeasureItem measureItem, ICurrencyItem currencyItem = null)
{
// unit calculus: [C1] = [C2/M1] * [M2 * (M1/M2)] * [C1/C2]
// C1, C2 - currency units; M1, M2 - measure units
Prepare(unitPrice, currencyItem);
MeasureItem = measureItem.ThrowIfNull(nameof(measureItem));
MeasureRate = MeasureItem.AmountOf(UnitPrice.MeasureUnit);
Amount = MeasureItem.Amount;
}
public void TryVerifyPackage(Hash packageId)
{
if (!packageRegistry.TryGetPackage(packageId, out LocalPackageInfo package) || package.LockProvider.IsMarkedToDelete)
{
return;
}
// create lock
lock (syncLock)
{
if (!packagesInVerify.Add(packageId))
{
return;
}
}
// run
var measureItem = new MeasureItem(MeasureType.Throughput);
var extractTask = validator.ValidatePackageAsync(package, measureItem).ContinueWith(t => {
if (t.IsFaulted && !t.Result.IsValid)
{
throw new Exception(string.Join("; ", t.Result.Errors));
}
});
// return lock
extractTask.ContinueWith(t =>
{
// release lock
lock (syncLock) { packagesInVerify.Remove(packageId); }
if (t.IsFaulted)
{
throw t.Exception;
}
});
// create and register task for starting download
var task = new LongRunningTask(
$"Validation of \"{package.Metadata.Name}\" {package.Id:s}",
extractTask,
$"Package is valid.",
t => $"Validating {measureItem.ValueFormatted}"
);
// register
tasks.AddTaskToQueue(task);
}
public void CreateNewPackage(string folder, string name)
{
if (!Directory.Exists(folder))
{
throw new InvalidOperationException("Folder does not exists.");
}
// start
var measureItem = new MeasureItem(MeasureType.Throughput);
Task taskCreate = Task.Run(new Action(() => packageRegistry.CreatePackageFromFolder(folder, name, measureItem)));
// create and register task for starting download
var task = new LongRunningTask(
$"Started creating new package from: \"{folder}\"",
taskCreate,
$"Package has been created.",
(t) => $"Writing {measureItem.ValueFormatted}"
);
// register
tasks.AddTaskToQueue(task);
}
private View ItemBuilder(Context context, int wheelIndex, int itemIndex, View reusableView, bool isSelected, object data, Rect rect, MeasureItem childChanged)
{
var view = (ViewGroup)reusableView ?? CreateCell(context, wheelIndex); //Create/use same cell for all wheels and index
var textView = view.FindViewById <TextView>(Resource.Id.valueText);
textView.Text = data.ToString();
textView.SetTextColor(isSelected ? Color.Red : Color.Black);
childChanged(view, false);
return(view);
}
public async Task <PackageDataValidatorResult> ValidatePackageAsync(LocalPackageInfo packageInfo, MeasureItem measure)
{
logger.LogDebug($"Starting validation of package {packageInfo}.");
var result = await ValidatePackageAsyncInternal(packageInfo);
if (result.IsValid)
{
logger.LogInformation($"Package {packageInfo} is valid.");
}
else
{
logger.LogWarning($"Package {packageInfo} validation FAILED:\n{string.Join("\n", result.Errors)}");
}
return(result);
}
/// <summary>
/// Raises the <see cref="E:MeasureItem"/> event.
/// </summary>
/// <param name="e">The <see cref="MeasureStepListItemEventArgs"/> instance containing the event data.</param>
protected virtual void OnMeasureItem(MeasureStepListItemEventArgs e)
{
MeasureItem?.Invoke(this, e);
}
protected virtual void OnMeasureItem(MeasureItemEventArgs args)
{
MeasureItem?.Invoke(this, args);
}
public LocalPackageInfo CreatePackageFromFolder(string folderToProcess, string name, MeasureItem writeMeasure)
{
var operationMeasure = Stopwatch.StartNew();
// storage folder for package
EnsurePath();
name = string.IsNullOrWhiteSpace(name) ? FileHelper.GetFileOrDirectoryName(folderToProcess) : name;
DirectoryInfo buildDirectory = Directory.CreateDirectory(CreateBuildPath());
logger.LogInformation($"Creating package \"{name}\" from folder: {folderToProcess}");
// create package archive
PackageHashes packageHashes;
int entriesCount;
using (var controller = new CreatePackageDataStreamController(app.Version, app.LoggerFactory, app.Crypto, sequenceForNewPackages, buildDirectory.FullName))
{
using (var packageStream = new PackageDataStream(app.LoggerFactory, controller)
{
Measure = writeMeasure
})
{
var archive = new PackageArchive(app.CompatibilityChecker, app.MessageSerializer);
archive.WriteFromFolder(folderToProcess, packageStream);
entriesCount = archive.EntriesCount;
}
packageHashes = controller.PackageId;
}
// store package hashes
UpdateHashes(packageHashes, directoryPath: buildDirectory.FullName);
// store download status
PackageSequenceInfo packageSequence = packageHashes.CreatePackageSequence();
PackageDownloadInfo downloadStatus = PackageDownloadInfo.CreateForCreatedPackage(app.Version, packageHashes.PackageId, packageSequence);
UpdateDownloadStatus(downloadStatus, directoryPath: buildDirectory.FullName);
// store metadata
var metadata = new PackageMeta()
{
Created = DateTimeOffset.Now,
Name = name,
PackageSize = packageHashes.PackageSize,
Version = app.Version,
PackageId = packageHashes.PackageId
};
UpdateMetadata(metadata, directoryPath: buildDirectory.FullName);
// rename folder
string packagePath = CreatePackagePath(packageHashes.PackageId);
if (Directory.Exists(packagePath))
{
throw new InvalidOperationException($"Folder for package {packageHashes.PackageId:s} already exists. {packagePath}");
}
Directory.Move(buildDirectory.FullName, packagePath);
operationMeasure.Stop();
logger.LogInformation($"Created package \"{packagePath}\":\nHash: {packageHashes.PackageId}\nSize: {SizeFormatter.ToString(packageHashes.PackageSize)}\nFiles and directories: {entriesCount}\nTime: {operationMeasure.Elapsed}");
var reference = new PackageReference(packagePath, packageHashes.PackageId);
var result = new LocalPackageInfo(reference, downloadStatus, packageHashes, metadata, packageSequence);
return(result);
}
