public IEventBuilder MapFrom(FlatContainer flatEventContainer)
{
var eventBuilder = _objectBaseFactory.Create <IEventBuilder>();
eventBuilder.Name = flatEventContainer.Name;
var flatEventCondition = _flatEventConditionRepo.EventConditionFor(flatEventContainer.Id);
eventBuilder.OneTime = flatEventCondition.IsOneTime;
eventBuilder.Formula =
_formulaFactory.RateFor(flatEventCondition, _formulaCache);
//add time reference to event condition formula
if (!eventBuilder.Formula.ContainsTimePath())
{
eventBuilder.Formula.AddObjectPath(_objectPathFactory.CreateTimePath(_dimensionRepository.Time));
}
// fill event assignments
foreach (var flatEventAssignment in _flatEventChangedObjectRepo.ChangedObjectsFor(flatEventContainer.Id))
{
var eventAssignment = _eventAssignmentBuilderMapper.MapFrom(flatEventAssignment);
eventAssignment.Name = $"Assignment_{eventBuilder.Assignments.Count() + 1}";
eventBuilder.AddAssignment(eventAssignment);
}
return(eventBuilder);
}
public IApplicationBuilder MapFrom(FlatContainer flatApplicationContainer)
{
var applicationBuilder = MapCommonPropertiesFrom(flatApplicationContainer);
//Set molecule name to "DRUG".
//Must be replaced during simulation building process
applicationBuilder.MoleculeName = CoreConstants.Molecule.Drug;
//Add application processes (e.g. infusion)
addApplicationProcessesTo(applicationBuilder);
//create parent formulation container of the application
//(in order to resolve paths of application subobjects correctly)
createParentFormulation(applicationBuilder, flatApplicationContainer.ParentId);
//Add substructure (subcontainers with parameters and events)
addApplicationStructureTo(applicationBuilder);
//add application (=event group) source criteria
//Each application will be settled under ApplicationSet-Container of
//the simulation
addApplicationSourceCriteria(applicationBuilder);
return(applicationBuilder);
}
private async Task <bool?> IsPackageIdenticalOnFeedAsync(
string item,
PackageIndex packageIndex,
ISleetFileSystem source,
FlatContainer flatContainer,
SleetLogger log)
{
using (var package = new PackageArchiveReader(item))
{
var id = await package.GetIdentityAsync(CancellationToken);
if (await packageIndex.Exists(id))
{
using (Stream remoteStream = await source
.Get(flatContainer.GetNupkgPath(id))
.GetStream(log, CancellationToken))
using (var remote = new MemoryStream())
{
await remoteStream.CopyToAsync(remote);
byte[] existingBytes = remote.ToArray();
byte[] localBytes = File.ReadAllBytes(item);
return(existingBytes.SequenceEqual(localBytes));
}
}
return(null);
}
}
public IEventGroupBuilder MapFrom(FlatContainer eventGroupFlatContainer)
{
var eventGroup = MapCommonPropertiesFrom(eventGroupFlatContainer);
foreach (var flatSubContainer in eventGroupSubContainers(eventGroupFlatContainer))
{
if (flatSubContainer.Type.Equals(CoreConstants.ContainerType.EVENT_GROUP))
{
eventGroup.Add(MapFrom(flatSubContainer));
continue;
}
if (flatSubContainer.Type.Equals(CoreConstants.ContainerType.EVENT))
{
eventGroup.Add(_eventMapper.MapFrom(flatSubContainer));
continue;
}
throw new PKSimException(PKSimConstants.Error.EventGroupSubContainerHasInvalidType);
}
addParametersTo(eventGroup);
//every event group will be added into events-subcontainer of simulation
eventGroup.SourceCriteria.Add(new MatchTagCondition(CoreConstants.Tags.EVENTS));
return eventGroup;
}
public async Task Symbols_AddSymbolsPackageWithNoValidSymbolsVerifyFeed()
{
using (var testContext = new SleetTestContext())
{
var context = testContext.SleetContext;
context.SourceSettings.SymbolsEnabled = true;
var symbols = new Symbols(context);
var packageIndex = new PackageIndex(context);
var catalog = new Catalog(context);
var autoComplete = new AutoComplete(context);
var flatContainer = new FlatContainer(context);
var registrations = new Registrations(context);
var search = new Search(context);
// Create package
var pkgA = new TestNupkg("a", "1.0.0");
pkgA.Nuspec.IsSymbolPackage = true;
var zip = pkgA.Save(testContext.Packages);
var pkgInput = testContext.GetPackageInput(zip);
// Init
var success = await InitCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
enableCatalog : true,
enableSymbols : true,
log : testContext.SleetContext.Log,
token : CancellationToken.None);
// Push
success &= await PushCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
new List <string>() { zip.FullName },
force : false,
skipExisting : false,
log : testContext.SleetContext.Log);
// Validate
success &= await ValidateCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
testContext.SleetContext.Log);
success.Should().BeTrue();
// The nupkg should exist, but there should not be any assets added.
(await symbols.GetSymbolsPackagesAsync()).Should().BeEmpty();
(await packageIndex.GetSymbolsPackagesAsync()).Should().NotBeEmpty();
// Verify nupkg exists
var nupkgPath = Path.Combine(testContext.Target, "symbols", "packages", "a", "1.0.0", "a.1.0.0.symbols.nupkg");
File.Exists(nupkgPath).Should().BeTrue();
// Verify package details
var detailsPath = Path.Combine(testContext.Target, "symbols", "packages", "a", "1.0.0", "package.json");
File.Exists(detailsPath).Should().BeTrue();
}
}
public Formulation MapFrom(FlatContainer flatContainer)
{
var formulation = _containerIdToFormulationMapper.MapFrom(flatContainer);
_parameterContainerTask.AddFormulationParametersTo(formulation);
formulation.IsLoaded = true;
return(formulation);
}
private IEnumerable<FlatContainer> eventGroupSubContainers(FlatContainer eventGroupFlatContainer)
{
return from flatContainer in _flatContainerRepository.All()
let parentContainer = _flatContainerRepository.ParentContainerFrom(flatContainer.Id)
where parentContainer != null
where parentContainer.Id == eventGroupFlatContainer.Id
select flatContainer;
}
protected override void Context()
{
base.Context();
_formulation = A.Fake <PKSim.Core.Model.Formulation>();
_formulationFlatContainer = new FlatContainer();
_formulationFlatContainer.Type = CoreConstants.ContainerType.Formulation;
_formulationFlatContainer.Name = "tralal";
A.CallTo(() => _containerIdToFormulationMapper.MapFrom(_formulationFlatContainer)).Returns(_formulation);
}
public T MapCommonPropertiesFrom(FlatContainerId flatContainerId)
{
FlatContainer = _flatContainerRepository.ContainerFrom(flatContainerId.Id);
var container = _objectBaseFactory.Create <T>().WithName(FlatContainer.Name);
addTagsToContainer(container, flatContainerId.Id);
container.Mode = FlatContainer.IsLogical ? ContainerMode.Logical : ContainerMode.Physical;
return(container);
}
public Formulation MapFrom(FlatContainer flatContainer)
{
var formulation = _objectBaseFactory.Create <Formulation>();
formulation.Root = _objectBaseFactory.Create <IRootContainer>();
formulation.Name = flatContainer.Name;
//save formulation name as formulation type too,
//because name can be overwritten by user
formulation.FormulationType = formulation.Name;
foreach (var formulationRoute in _formulationRouteRepo.All().Where(fr => fr.Formulation.Equals(formulation.Name)))
{
formulation.AddRoute(formulationRoute.Route);
}
return(formulation);
}
protected override void Context()
{
base.Context();
_formulationFlatContainer = _flatContainerRepository.All().First(x => x.Type == CoreConstants.ContainerType.Formulation);
}
private async Task <bool> PushAsync(
IEnumerable <string> items,
PushOptions options)
{
LocalSettings settings = GetSettings();
AzureFileSystem fileSystem = GetAzureFileSystem();
SleetLogger log = new SleetLogger(Log);
var packagesToPush = items.ToList();
if (!options.AllowOverwrite && options.PassIfExistingItemIdentical)
{
var context = new SleetContext
{
LocalSettings = settings,
Log = log,
Source = fileSystem,
Token = CancellationToken
};
context.SourceSettings = await FeedSettingsUtility.GetSettingsOrDefault(
context.Source,
context.Log,
context.Token);
var flatContainer = new FlatContainer(context);
var packageIndex = new PackageIndex(context);
// Check packages sequentially: Task.WhenAll caused IO exceptions in Sleet.
for (int i = packagesToPush.Count - 1; i >= 0; i--)
{
string item = packagesToPush[i];
bool?identical = await IsPackageIdenticalOnFeedAsync(
item,
packageIndex,
context.Source,
flatContainer,
log);
if (identical == null)
{
continue;
}
packagesToPush.RemoveAt(i);
if (identical == true)
{
Log.LogMessage(
MessageImportance.Normal,
"Package exists on the feed, and is verified to be identical. " +
$"Skipping upload: '{item}'");
}
else
{
Log.LogError(
"Package exists on the feed, but contents are different. " +
$"Upload failed: '{item}'");
}
}
if (!packagesToPush.Any())
{
Log.LogMessage("After skipping idempotent uploads, no items need pushing.");
return(true);
}
}
return(await PushCommand.RunAsync(
settings,
fileSystem,
packagesToPush,
options.AllowOverwrite,
skipExisting : false,
log : log));
}
private ICache <int, FlatPopulationContainer> populationSubContainers(SpeciesPopulation population, FlatContainer parentContainer)
{
var result = new Cache <int, FlatPopulationContainer>(x => x.Id);
result.AddRange(_populationContainerRepo.AllSubContainerFor(population.Name, parentContainer.Id));
return(result);
}
public async Task Symbols_AddSymbolsPackageVerifyFeed()
{
using (var testContext = new SleetTestContext())
{
var context = testContext.SleetContext;
context.SourceSettings.SymbolsEnabled = true;
var symbols = new Symbols(context);
var packageIndex = new PackageIndex(context);
var catalog = new Catalog(context);
var autoComplete = new AutoComplete(context);
var flatContainer = new FlatContainer(context);
var registrations = new Registrations(context);
var search = new Search(context);
// Create package
var pkgA = new TestNupkg("a", "1.0.0");
pkgA.Files.Clear();
pkgA.AddFile("lib/net45/a.dll", TestUtility.GetResource("SymbolsTestAdll").GetBytes());
pkgA.AddFile("lib/net45/a.pdb", TestUtility.GetResource("SymbolsTestApdb").GetBytes());
pkgA.Nuspec.IsSymbolPackage = true;
var zip = pkgA.Save(testContext.Packages);
var pkgInput = testContext.GetPackageInput(zip);
// Init
var success = await InitCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
enableCatalog : true,
enableSymbols : true,
log : testContext.SleetContext.Log,
token : CancellationToken.None);
// Push
success &= await PushCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
new List <string>() { zip.FullName },
force : false,
skipExisting : false,
log : testContext.SleetContext.Log);
// Validate
success &= await ValidateCommand.RunAsync(
testContext.SleetContext.LocalSettings,
testContext.SleetContext.Source,
testContext.SleetContext.Log);
success.Should().BeTrue();
// Exists under symbols
(await symbols.GetSymbolsPackagesAsync()).Should().NotBeEmpty();
(await packageIndex.GetSymbolsPackagesAsync()).Should().NotBeEmpty();
// Does not exist in non-symbols
(await symbols.GetPackagesAsync()).Should().BeEmpty();
(await packageIndex.GetPackagesAsync()).Should().BeEmpty();
// Verify it does not appear in other services
(await catalog.GetPackagesAsync()).Should().BeEmpty();
(await autoComplete.GetPackageIds()).Should().BeEmpty();
(await flatContainer.GetPackagesByIdAsync("a")).Should().BeEmpty();
(await registrations.GetPackagesByIdAsync("a")).Should().BeEmpty();
(await search.GetPackagesAsync()).Should().BeEmpty();
// Verify nupkg exists
var nupkgPath = Path.Combine(testContext.Target, "symbols", "packages", "a", "1.0.0", "a.1.0.0.symbols.nupkg");
File.Exists(nupkgPath).Should().BeTrue();
// Verify package details
var detailsPath = Path.Combine(testContext.Target, "symbols", "packages", "a", "1.0.0", "package.json");
File.Exists(detailsPath).Should().BeTrue();
}
}
public IEventBuilder MapFrom(FlatContainer flatEventContainer, IFormulaCache formulaCache)
{
_formulaCache = formulaCache;
return(MapFrom(flatEventContainer));
}
public bool ContainerIsFormulation(FlatContainer container)
{
return(string.Equals(container.Type, CoreConstants.ContainerType.Formulation) && container.Visible);
}
private async Task <bool> PushAsync(
IEnumerable <string> items,
PushOptions options)
{
LocalSettings settings = GetSettings();
SleetLogger log = new SleetLogger(Log, NuGet.Common.LogLevel.Verbose);
var packagesToPush = items.ToList();
// Create a separate LocalCache to use for read only operations on the feed.
// Files added to the cache before the lock could be modified by the process
// currently holding the lock. Sleet assumes that files in the cache
// are valid and identical to the ones on the feed since operations are
// normally performed inside the lock.
using (var preLockCache = CreateFileCache())
{
var preLockFileSystem = GetAzureFileSystem(preLockCache);
if (!options.AllowOverwrite && options.PassIfExistingItemIdentical)
{
var context = new SleetContext
{
LocalSettings = settings,
Log = log,
Source = preLockFileSystem,
Token = CancellationToken
};
context.SourceSettings = await FeedSettingsUtility.GetSettingsOrDefault(
context.Source,
context.Log,
context.Token);
var flatContainer = new FlatContainer(context);
var packageIndex = new PackageIndex(context);
// Check packages sequentially: Task.WhenAll caused IO exceptions in Sleet.
for (int i = packagesToPush.Count - 1; i >= 0; i--)
{
string item = packagesToPush[i];
bool?identical = await IsPackageIdenticalOnFeedAsync(
item,
packageIndex,
context.Source,
flatContainer,
log);
if (identical == null)
{
continue;
}
packagesToPush.RemoveAt(i);
if (identical == true)
{
Log.LogMessage(
MessageImportance.Normal,
"Package exists on the feed, and is verified to be identical. " +
$"Skipping upload: '{item}'");
}
else
{
Log.LogError(
"Package exists on the feed, but contents are different. " +
$"Upload failed: '{item}'");
}
}
if (!packagesToPush.Any())
{
Log.LogMessage("After skipping idempotent uploads, no items need pushing.");
return(true);
}
}
}
// Create a new cache to be used once a lock is obtained.
using (var fileCache = CreateFileCache())
{
var lockedFileSystem = GetAzureFileSystem(fileCache);
return(await PushCommand.RunAsync(
settings,
lockedFileSystem,
packagesToPush,
options.AllowOverwrite,
skipExisting : false,
log : log));
}
}
private string applicationTypeFrom(FlatContainer flatApplicContainer)
{
return((from flatApplication in _flatApplicRepository.All()
where string.Equals(flatApplication.Name, flatApplicContainer.Name)
select flatApplication.ApplicationType).FirstOrDefault());
}
