Example #1
0
 public static void SetInitialVersion(ApplicationInfo productVersion)
 {
     // create an in-memory, initial version
     __instance = Create(productVersion, new List <ApplicationInfo>(), new List <Package>());
 }
Example #2
0
 private static void ResetPrivate()
 {
     __instance = null;
 }
Example #3
0
        public static RepositoryInstance Start(RepositoryBuilder builder)
        {
            var connectionStrings = builder.Services?.GetRequiredService <IOptions <ConnectionStringOptions> >();

            Providers.Instance.InitializeBlobProviders(connectionStrings?.Value ?? new ConnectionStringOptions());

            EnsureDatabase(builder);

            var initialData = builder.InitialData;

            if (initialData != null)
            {
                Providers.Instance.DataStore.InstallInitialDataAsync(initialData, CancellationToken.None)
                .GetAwaiter().GetResult();
            }

            RepositoryInstance repositoryInstance = null;
            var exclusiveLockOptions = builder.Services?.GetService <IOptions <ExclusiveLockOptions> >()?.Value;

            ExclusiveBlock.RunAsync("SenseNet.PatchManager", Guid.NewGuid().ToString(),
                                    ExclusiveBlockType.WaitAndAcquire, exclusiveLockOptions, CancellationToken.None, () =>
            {
                var logger       = Providers.Instance.GetProvider <ILogger <SnILogger> >();
                var patchManager = new PatchManager(builder, logRecord => { logRecord.WriteTo(logger); });
                patchManager.ExecutePatchesOnBeforeStart();

                repositoryInstance = Start((RepositoryStartSettings)builder);

                var permissions = initialData?.Permissions;
                if (permissions != null && permissions.Count > 0)
                {
                    new SecurityInstaller(Providers.Instance.SecurityHandler, Providers.Instance.StorageSchema,
                                          Providers.Instance.DataStore).InstallDefaultSecurityStructure(initialData);
                }

                var indexingEngine = Providers.Instance.SearchEngine.IndexingEngine;
                if (indexingEngine.Running)
                {
                    if (initialData?.IndexDocuments != null)
                    {
                        // Build the index from an in-memory structure. This is a developer use case.
                        indexingEngine.ClearIndexAsync(CancellationToken.None)
                        .ConfigureAwait(false).GetAwaiter().GetResult();
                        indexingEngine.WriteIndexAsync(null, null,
                                                       initialData.IndexDocuments, CancellationToken.None)
                        .ConfigureAwait(false).GetAwaiter().GetResult();
                    }
                    else
                    {
                        // make sure the index exists and contains documents
                        EnsureIndex(builder);
                    }
                }

                patchManager.ExecutePatchesOnAfterStart();
                RepositoryVersionInfo.Reset();

                return(System.Threading.Tasks.Task.CompletedTask);
            }).GetAwaiter().GetResult();

            return(repositoryInstance);
        }