public System.Threading.Tasks.Task SavePackageAsync(Package package, CancellationToken cancellationToken) { if (package.Id > 0) { throw new InvalidOperationException("Only new package can be saved."); } var collection = GetPackages(); var newId = collection.Count == 0 ? 1 : collection.Max(t => t.Id) + 1; var packageDoc = new PackageDoc { Id = newId, Description = package.Description, ComponentId = package.ComponentId, PackageType = package.PackageType, ReleaseDate = package.ReleaseDate, ExecutionDate = package.ExecutionDate, ExecutionResult = package.ExecutionResult, ComponentVersion = package.ComponentVersion, ExecutionError = package.ExecutionError, Manifest = package.Manifest, }; package.Id = newId; collection.Insert(packageDoc); RepositoryVersionInfo.Reset(); return(System.Threading.Tasks.Task.CompletedTask); }
private static void SavePackage(Manifest manifest, ExecutionContext executionContext, bool successful, Exception execError) { var executionResult = successful ? ExecutionResult.Successful : ExecutionResult.Faulty; var isAppPack = manifest.Type == PackageType.Application; RepositoryVersionInfo.Reset(); var oldPacks = isAppPack ? RepositoryVersionInfo.Instance.InstalledPackages .Where(p => p.AppId == manifest.AppId && p.ApplicationVersion == manifest.VersionControl.Target) .OrderBy(p => p.ExecutionDate).ToList() : RepositoryVersionInfo.Instance.InstalledPackages .Where(p => p.AppId == manifest.AppId && p.SenseNetVersion == manifest.VersionControl.Target) .OrderBy(p => p.ExecutionDate).ToList(); var oldPack = oldPacks.LastOrDefault(); if (oldPack == null) { var newPack = CreatePackage(manifest, executionResult, execError); DataProvider.Current.SavePackage(newPack); } else { UpdatePackage(oldPack, manifest, executionResult, execError); DataProvider.Current.UpdatePackage(oldPack); } }
internal static void SavePackage(Manifest manifest, ExecutionResult executionResult, Exception execError) { RepositoryVersionInfo.Reset(); var oldPacks = RepositoryVersionInfo.Instance.InstalledPackages; if (manifest.PackageType == PackageType.Tool) { oldPacks = oldPacks .Where(p => p.ComponentId == manifest.ComponentId && p.PackageType == PackageType.Tool && p.ExecutionResult == ExecutionResult.Unfinished); } else { oldPacks = oldPacks .Where(p => p.ComponentId == manifest.ComponentId && p.ComponentVersion == manifest.Version); } oldPacks = oldPacks.OrderBy(p => p.ExecutionDate).ToArray(); var oldPack = oldPacks.LastOrDefault(); if (oldPack == null) { var newPack = CreatePackage(manifest, executionResult, execError); Storage.SavePackageAsync(newPack, CancellationToken.None).GetAwaiter().GetResult(); } else { UpdatePackage(oldPack, manifest, executionResult, execError); Storage.UpdatePackageAsync(oldPack, CancellationToken.None).GetAwaiter().GetResult(); } }
private static void SavePackage(Manifest manifest, ExecutionContext executionContext, bool successful, Exception execError) { var executionResult = successful ? ExecutionResult.Successful : ExecutionResult.Faulty; RepositoryVersionInfo.Reset(); var oldPacks = RepositoryVersionInfo.Instance.InstalledPackages; if (manifest.PackageType == PackageType.Tool) { oldPacks = oldPacks .Where(p => p.ComponentId == manifest.ComponentId && p.PackageType == PackageType.Tool && p.ExecutionResult == ExecutionResult.Unfinished); } else { oldPacks = oldPacks .Where(p => p.ComponentId == manifest.ComponentId && p.ComponentVersion == manifest.Version); } oldPacks = oldPacks.OrderBy(p => p.ExecutionDate).ToArray(); var oldPack = oldPacks.LastOrDefault(); if (oldPack == null) { var newPack = CreatePackage(manifest, executionResult, execError); Storage.SavePackage(newPack); } else { UpdatePackage(oldPack, manifest, executionResult, execError); Storage.UpdatePackage(oldPack); } }
/* ==================================================================================== Package deletion */ public async Task Packaging_DeleteOne() { await PackagingTestAsync(async() => { await SavePackage("C1", "1.0", "00:00", "2016-01-01", PackageType.Install, ExecutionResult.Unfinished); await SavePackage("C1", "1.0", "01:00", "2016-01-01", PackageType.Install, ExecutionResult.Faulty); await SavePackage("C1", "1.0", "02:00", "2016-01-01", PackageType.Install, ExecutionResult.Successful); await SavePackage("C1", "1.1", "03:00", "2016-01-03", PackageType.Patch, ExecutionResult.Faulty); await SavePackage("C1", "1.1", "04:00", "2016-01-03", PackageType.Patch, ExecutionResult.Faulty); await SavePackage("C1", "1.1", "05:00", "2016-01-06", PackageType.Patch, ExecutionResult.Successful); await SavePackage("C1", "1.2", "06:00", "2016-01-07", PackageType.Patch, ExecutionResult.Unfinished); await SavePackage("C1", "1.2", "07:00", "2016-01-08", PackageType.Patch, ExecutionResult.Unfinished); await SavePackage("C1", "1.2", "08:00", "2016-01-09", PackageType.Patch, ExecutionResult.Faulty); await SavePackage("C1", "1.2", "09:00", "2016-01-09", PackageType.Patch, ExecutionResult.Faulty); await SavePackage("C1", "1.2", "10:00", "2016-01-09", PackageType.Patch, ExecutionResult.Successful); // action: delete all faulty and unfinished var packs = RepositoryVersionInfo.Instance.InstalledPackages .Where(p => p.ExecutionResult != ExecutionResult.Successful); foreach (var package in packs) { await PackageManager.Storage.DeletePackageAsync(package, CancellationToken.None); } RepositoryVersionInfo.Reset(); // check var actual = string.Join(" | ", RepositoryVersionInfo.Instance.InstalledPackages .OrderBy(p => p.ComponentVersion) .Select(p => $"{p.PackageType.ToString()[0]}:{p.ComponentVersion}-{p.ExecutionDate.Hour}") .ToArray()); var expected = "I:1.0-2 | P:1.1-5 | P:1.2-10"; Assert.AreEqual(expected, actual); }).ConfigureAwait(false); }
private void CheckPrerequisits(PackageParameter[] packageParameters, bool forcedReinstall, bool log, bool editConnectionString) { if (log) { Logger.LogMessage("ComponentId: {0}", this.ComponentId); Logger.LogMessage("PackageType: " + this.PackageType); Logger.LogMessage("Package version: " + this.Version); if (SystemInstall) { Logger.LogMessage(forcedReinstall ? "FORCED REINSTALL" : "SYSTEM INSTALL"); } } if (SystemInstall && editConnectionString) { EditConnectionString(this.Parameters, packageParameters); RepositoryVersionInfo.Reset(); } var versionInfo = RepositoryVersionInfo.Instance; var existingComponentInfo = versionInfo.Components.FirstOrDefault(a => a.ComponentId == ComponentId); if (PackageType == PackageType.Install) { if (!(forcedReinstall && SystemInstall) && existingComponentInfo != null) { // Install packages can be executed multiple times only if it is // allowed in the package AND the version in the manifest is the // same as in the db. if (!this.MultipleExecutionAllowed || existingComponentInfo.Version != this.Version) { throw new PackagePreconditionException( string.Format(SR.Errors.Precondition.CannotInstallExistingComponent1, this.ComponentId), PackagingExceptionType.CannotInstallExistingComponent); } } } else if (PackageType != PackageType.Tool) { if (existingComponentInfo == null) { throw new PackagePreconditionException(string.Format(SR.Errors.Precondition.CannotUpdateMissingComponent1, this.ComponentId), PackagingExceptionType.CannotUpdateMissingComponent); } if (existingComponentInfo.Version >= this.Version) { throw new PackagePreconditionException(string.Format(SR.Errors.Precondition.TargetVersionTooSmall2, this.Version, existingComponentInfo.Version), PackagingExceptionType.TargetVersionTooSmall); } } if (log && this.Dependencies.Any()) { Logger.LogMessage("Dependencies:"); } foreach (var dependency in this.Dependencies) { CheckDependency(dependency, versionInfo, log); } }
internal static PackagingResult ExecutePhase(XmlDocument manifestXml, int phase, RepositoryStartSettings settings = null) { var manifest = Manifest.Parse(manifestXml, phase, true, new PackageParameter[0]); // Fill context with indexing folder, repo start settings, providers and other // parameters necessary for on-the-fly steps to run. var executionContext = ExecutionContext.Create("packagePath", "targetPath", new string[0], "sandboxPath", manifest, phase, manifest.CountOfPhases, null, null, settings); PackagingResult result; try { result = ExecuteCurrentPhase(manifest, executionContext); } finally { if (Repository.Started()) { SnTrace.System.Write("PackageManager: stopping repository ... "); Repository.Shutdown(); } } RepositoryVersionInfo.Reset(); return(result); }
protected PackagingResult ExecutePhase(XmlDocument manifestXml, int phase, TextWriter console = null) { var manifest = Manifest.Parse(manifestXml, phase, true, new PackageParameter[0]); var executionContext = ExecutionContext.CreateForTest("packagePath", "targetPath", new string[0], "sandboxPath", manifest, phase, manifest.CountOfPhases, null, console); var result = PackageManager.ExecuteCurrentPhase(manifest, executionContext); RepositoryVersionInfo.Reset(); return(result); }
private void InitializePackagingTest(RepositoryBuilder builder) { _log = new StringBuilder(); var loggers = new[] { new PackagingTestLogger(_log) }; var loggerAcc = new TypeAccessor(typeof(SenseNet.Packaging.Logger)); loggerAcc.SetStaticField("_loggers", loggers); RepositoryVersionInfo.Reset(); }
private async Task PackagingTestAsync(Func <Task> callback) { await NoRepoIntegrationTestAsync(async() => { await Providers.Instance.DataProvider .GetExtension <IPackagingDataProviderExtension>() .DeleteAllPackagesAsync(CancellationToken.None) .ConfigureAwait(false); RepositoryVersionInfo.Reset(); await callback().ConfigureAwait(false); }).ConfigureAwait(false); }
/* ==================================================================================== TOOLS */ private void PackagingTest(Action callback) { NoRepoIntegrationTest(() => { Providers.Instance.DataProvider .GetExtension <IPackagingDataProviderExtension>() .DeleteAllPackagesAsync(CancellationToken.None) .ConfigureAwait(false).GetAwaiter().GetResult(); RepositoryVersionInfo.Reset(); callback(); }); }
public void SavePackage(Package package) { if (package.Id > 0) { throw new InvalidOperationException("Only new package can be saved."); } package.Id = ++_id; Storage.Add(ClonePackage(package, true)); RepositoryVersionInfo.Reset(); }
public void PrepareTest() { // preparing logger _log = new StringBuilder(); var loggers = new[] { new PackagingTestLogger(_log) }; var loggerAcc = new PrivateType(typeof(Logger)); loggerAcc.SetStaticField("_loggers", loggers); var unused = CreateRepositoryBuilderForTestInstance(); RepositoryVersionInfo.Reset(); }
public Task SavePackageAsync(Package package, CancellationToken cancellationToken) { if (package.Id > 0) { throw new InvalidOperationException("Only new package can be saved."); } package.Id = ++_id; Storage.Add(ClonePackage(package, true)); RepositoryVersionInfo.Reset(); return(Task.CompletedTask); }
public void PrepareTest() { // preparing logger _log = new StringBuilder(); var loggers = new[] { new PackagingTestLogger(_log) }; var loggerAcc = new TypeAccessor(typeof(Logger)); loggerAcc.SetStaticField("_loggers", loggers); var builder = CreateRepositoryBuilderForTest(); builder.UsePackagingDataProviderExtension(new InMemoryPackageStorageProvider()); RepositoryVersionInfo.Reset(); }
public void PrepareTest() { // preparing logger _log = new StringBuilder(); var loggers = new[] { new PackagingTestLogger(_log) }; var loggerAcc = new PrivateType(typeof(Logger)); loggerAcc.SetStaticField("_loggers", loggers); var storage = new TestPackageStorageProvider(); _packageStorageProviderFactoryBackup = PackageManager.StorageFactory; PackageManager.StorageFactory = new TestPackageStorageProviderFactory(storage); RepositoryVersionInfo.Reset(); }
public void PrepareTest() { // preparing logger _log = new StringBuilder(); var loggers = new[] { new PackagingTestLogger(_log) }; var loggerAcc = new TypeAccessor(typeof(Logger)); loggerAcc.SetStaticField("_loggers", loggers); var builder = CreateRepositoryBuilderForTest(TestContext, services => { services.AddSingleton <IPackagingDataProvider, InMemoryPackageStorageProvider>(); }); RepositoryVersionInfo.Reset(); }
private void InitializePackagingTest(RepositoryBuilder builder) { _log = new StringBuilder(); var loggers = new[] { new PackagingTestLogger(_log) }; var loggerAcc = new TypeAccessor(typeof(SenseNet.Packaging.Logger)); loggerAcc.SetStaticField("_loggers", loggers); using (var ctx = new MsSqlDataContext(ConnectionStrings.ConnectionString, DataOptions.GetLegacyConfiguration(), CancellationToken.None)) { DropPackagesTable(ctx); InstallPackagesTable(ctx); } RepositoryVersionInfo.Reset(); }
/*================================================= tools */ protected async Task SavePackage(string id, string version, string execTime, string releaseDate, PackageType packageType, ExecutionResult result) { var package = new Package { ComponentId = id, ComponentVersion = Version.Parse(version), Description = $"{id}-Description", ExecutionDate = DateTime.Parse($"2017-03-30 {execTime}"), ReleaseDate = DateTime.Parse(releaseDate), ExecutionError = null, ExecutionResult = result, PackageType = packageType, }; await PackageManager.Storage.SavePackageAsync(package, CancellationToken.None); RepositoryVersionInfo.Reset(); }
public void InitializeTest() { // preparing logger _log = new StringBuilder(); var loggers = new[] { new PackagingTestLogger(_log) }; var loggerAcc = new PrivateType(typeof(Logger)); loggerAcc.SetStaticField("_loggers", loggers); // preparing database ConnectionStrings.ConnectionString = ConnectionString; var proc = DataProvider.CreateDataProcedure("DELETE FROM [Packages]"); proc.CommandType = CommandType.Text; proc.ExecuteNonQuery(); proc = DataProvider.CreateDataProcedure("DBCC CHECKIDENT ('[Packages]', RESEED, 1)"); proc.CommandType = CommandType.Text; proc.ExecuteNonQuery(); RepositoryVersionInfo.Reset(); }
internal static void SavePackage(Manifest manifest, ExecutionResult executionResult, Exception execError, bool insertOnly = false) { // Ensure consistency of local version-info before determining the installed packages. RepositoryVersionInfo.Reset(true); var oldPacks = RepositoryVersionInfo.Instance.InstalledPackages; if (manifest.PackageType == PackageType.Tool) { oldPacks = oldPacks .Where(p => p.ComponentId == manifest.ComponentId && p.PackageType == PackageType.Tool && p.ExecutionResult == ExecutionResult.Unfinished); } else { oldPacks = oldPacks .Where(p => p.ComponentId == manifest.ComponentId && p.ComponentVersion == manifest.Version); } oldPacks = oldPacks.OrderBy(p => p.ExecutionDate).ToArray(); var oldPack = oldPacks.LastOrDefault(); if (oldPack == null || insertOnly) { var newPack = CreatePackage(manifest, executionResult, execError); Storage.SavePackageAsync(newPack, CancellationToken.None).GetAwaiter().GetResult(); } else { UpdatePackage(oldPack, manifest, executionResult, execError); Storage.UpdatePackageAsync(oldPack, CancellationToken.None).GetAwaiter().GetResult(); } // Ensure consistency of local version-info after persisting every executed package. RepositoryVersionInfo.Reset(true); }
private static void PatchAndCheck(string componentId, Version[] packageVersions, Version[] successfulPatchVersions, Version[] failedPatchVersions, Version expectedVersion) { Version initialVersion = null; // install mock packages if (packageVersions?.Any() ?? false) { // the first should be an install package, Patch packages will follow var install = true; foreach (var packageVersion in packageVersions) { PackageManager.Storage.SavePackage(new Package { ComponentId = componentId, ComponentVersion = packageVersion, ExecutionResult = ExecutionResult.Successful, PackageType = install ? PackageType.Install : PackageType.Patch }); install = false; } RepositoryVersionInfo.Reset(); initialVersion = packageVersions.Last(); } var installedComponent = RepositoryVersionInfo.Instance.Components.Single(c => c.ComponentId == componentId); if (installedComponent != null) { Assert.AreEqual(initialVersion, installedComponent.Version); } var assemblyComponent = RepositoryVersionInfo.GetAssemblyComponents() .Single(c => c.ComponentId == componentId); // ACTION var results = PackageManager.ExecuteAssemblyPatches(assemblyComponent); // reload version info installedComponent = RepositoryVersionInfo.Instance.Components.Single(c => c.ComponentId == componentId); if (successfulPatchVersions?.Any() ?? false) { // the component was successfully upgraded foreach (var patchVersion in successfulPatchVersions) { Assert.IsTrue(results[patchVersion].Successful); } } if (failedPatchVersions?.Any() ?? false) { // there should be failed patch results foreach (var patchVersion in failedPatchVersions) { Assert.IsFalse(results[patchVersion].Successful); } } if (!(successfulPatchVersions?.Any() ?? false) && !(failedPatchVersions?.Any() ?? false)) { // no patch is expected Assert.IsFalse(results?.Keys.Any() ?? false); } if (installedComponent != null) { Assert.AreEqual(expectedVersion, installedComponent.Version); } }
internal static PackagingResult ExecuteCurrentPhase(Manifest manifest, ExecutionContext executionContext) { var sysInstall = manifest.SystemInstall; var currentPhase = executionContext.CurrentPhase; if (0 == currentPhase - (sysInstall ? 1 : 0)) { SaveInitialPackage(manifest); } var stepElements = manifest.GetPhase(executionContext.CurrentPhase); var stopper = Stopwatch.StartNew(); Logger.LogMessage("Executing steps"); Exception phaseException = null; var successful = false; try { var maxStepId = stepElements.Count; for (int i = 0; i < maxStepId; i++) { var stepElement = stepElements[i]; var step = Step.Parse(stepElement, i, executionContext); var stepStopper = Stopwatch.StartNew(); Logger.LogStep(step, maxStepId); step.Execute(executionContext); stepStopper.Stop(); Logger.LogMessage("-------------------------------------------------------------"); Logger.LogMessage("Time: " + stepStopper.Elapsed); if (executionContext.Terminated) { LogTermination(executionContext); break; } } stopper.Stop(); Logger.LogMessage("============================================================="); Logger.LogMessage("All steps were executed."); Logger.LogMessage("Aggregated time: " + stopper.Elapsed); Logger.LogMessage("Errors: " + Logger.Errors); successful = true; } catch (Exception e) { phaseException = e; } var finished = executionContext.Terminated || (executionContext.CurrentPhase == manifest.CountOfPhases - 1); if (successful && !finished) { return new PackagingResult { NeedRestart = true, Successful = true, Errors = Logger.Errors } } ; if (executionContext.Terminated && executionContext.TerminationReason == TerminationReason.Warning) { successful = false; phaseException = new PackageTerminatedException(executionContext.TerminationMessage); } try { SavePackage(manifest, executionContext, successful, phaseException); } catch (Exception e) { if (phaseException != null) { Logger.LogException(phaseException); } throw new PackagingException("Cannot save the package.", e); } finally { RepositoryVersionInfo.Reset(); // we need to shut down messaging, because the line above uses it if (!executionContext.Test) { DistributedApplication.ClusterChannel.ShutDown(); } else { Diagnostics.SnTrace.Test.Write("DistributedApplication.ClusterChannel.ShutDown SKIPPED because it is a test context."); } } if (!successful && !executionContext.Terminated) { throw new ApplicationException(String.Format(SR.Errors.PhaseFinishedWithError_1, phaseException.Message), phaseException); } return(new PackagingResult { NeedRestart = false, Successful = successful, Terminated = executionContext.Terminated && !successful, Errors = Logger.Errors }); }
private static PackagingResult ExecuteCurrentPhase(Manifest manifest, ExecutionContext executionContext) { if (executionContext.CurrentPhase == 0) { SaveInitialPackage(manifest); } var steps = manifest.GetPhase(executionContext.CurrentPhase); var stopper = Stopwatch.StartNew(); Logger.LogMessage("Executing steps"); Exception phaseException = null; var successful = false; try { var maxStepId = steps.Count(); foreach (var step in steps) { var stepStopper = Stopwatch.StartNew(); Logger.LogStep(step, maxStepId); step.Execute(executionContext); stepStopper.Stop(); Logger.LogMessage("-------------------------------------------------------------"); Logger.LogMessage("Time: " + stepStopper.Elapsed); } stopper.Stop(); Logger.LogMessage("============================================================="); Logger.LogMessage("All steps were executed."); Logger.LogMessage("Aggregated time: " + stopper.Elapsed); Logger.LogMessage("Errors: " + Logger.Errors); successful = true; } catch (Exception e) { phaseException = e; } if (successful && (executionContext.CurrentPhase < manifest.CountOfPhases - 1)) { return new PackagingResult { NeedRestart = true, Successful = true, Errors = Logger.Errors } } ; try { if (Logger.Level <= LogLevel.Default) { SavePackage(manifest, executionContext, successful, phaseException); } } finally { RepositoryVersionInfo.Reset(); //we need to shut down messaging, because the line above uses it DistributedApplication.ClusterChannel.ShutDown(); } if (!successful) { throw new ApplicationException(String.Format(SR.Errors.PhaseFinishedWithError_1, phaseException.Message), phaseException); } return(new PackagingResult { NeedRestart = false, Successful = true, Errors = Logger.Errors }); }
private static PackagingResult ExecuteCurrentPhase(Manifest manifest, ExecutionContext executionContext) { if (manifest.Type == PackageType.Product && manifest.Level == PackageLevel.Install) { // In case of product install create initial entry at the beginning of the // second phase, after the new db was created in the first phase. if (executionContext.CurrentPhase == 1) { SaveInitialPackage(manifest); } } else { if (executionContext.CurrentPhase == 0) { SaveInitialPackage(manifest); } } var stepElements = manifest.GetPhase(executionContext.CurrentPhase); var stopper = Stopwatch.StartNew(); Logger.LogMessage("Executing steps"); Exception phaseException = null; var successful = false; try { var maxStepId = stepElements.Count(); for (int i = 0; i < maxStepId; i++) { var stepElement = stepElements[i]; var step = Step.Parse(stepElement, i); executionContext.SubstituteParameters(step); var stepStopper = Stopwatch.StartNew(); Logger.LogStep(step, maxStepId); step.Execute(executionContext); stepStopper.Stop(); Logger.LogMessage("-------------------------------------------------------------"); Logger.LogMessage("Time: " + stepStopper.Elapsed); if (executionContext.Terminated) { LogTermination(executionContext); break; } } stopper.Stop(); Logger.LogMessage("============================================================="); Logger.LogMessage("All steps were executed."); Logger.LogMessage("Aggregated time: " + stopper.Elapsed); Logger.LogMessage("Errors: " + Logger.Errors); successful = true; } catch (Exception e) { phaseException = e; } var finished = executionContext.Terminated || (executionContext.CurrentPhase == manifest.CountOfPhases - 1); if (successful && !finished) { return new PackagingResult { NeedRestart = true, Successful = true, Errors = Logger.Errors } } ; if (executionContext.Terminated && executionContext.TerminationReason == TerminationReason.Warning) { successful = false; phaseException = new PackageTerminatedException(executionContext.TerminationMessage); } try { SavePackage(manifest, executionContext, successful, phaseException); } finally { RepositoryVersionInfo.Reset(); //we need to shut down messaging, because the line above uses it DistributedApplication.ClusterChannel.ShutDown(); } if (!successful && !executionContext.Terminated) { throw new ApplicationException(String.Format(SR.Errors.PhaseFinishedWithError_1, phaseException.Message), phaseException); } return(new PackagingResult { NeedRestart = false, Successful = successful, Terminated = executionContext.Terminated && !successful, Errors = Logger.Errors }); }