コード例 #1
0
        public OrchardAppHost(
            AppHostSettings settings,
            AppHostRegistrations registrations)
        {
            if (settings == null) settings = new AppHostSettings();
            if (registrations == null) registrations = new AppHostRegistrations();

            _settings = settings;
            _registrations = registrations;
        }
コード例 #2
0
        public static async Task RunSample(AppHostSettings settings)
        {
            Console.WriteLine("=== Loop sample starts === ");
            Console.WriteLine("Press Ctrl+C to exit the loop.");

            using (var host = await OrchardAppHostFactory.StartHost(settings))
            {
                var run = true;

                // Hit Ctrl+C to exit the loop, but not the app (other samples will follow up).
                Console.CancelKeyPress += (sender, e) =>
                    {
                        e.Cancel = true;
                        run = false;
                    };


                while (run)
                {
                    Console.WriteLine("Cycle starts.");


                    await host.Run<ILoggerService, IClock>((logger, clock) => Task.Run(() =>
                        {
                            logger.Error("Test log entry.");
                            Console.WriteLine(clock.UtcNow.ToString());
                        }));

                    // Another overload of Run() for simple transaction handling and for using the work context scope 
                    // directly.
                    await host.RunInTransaction(async scope =>
                        {
                            Console.WriteLine(scope.Resolve<ISiteService>().GetSiteSettings().SiteName);

                            // Simulating an async call. Because of this the delegate is marked as async (and we don't
                            // need to wrap it into a Task.Run()).
                            await Task.Delay(3000);

                            Console.WriteLine(scope.Resolve<ISiteService>().GetSiteSettings().SiteName);
                            Console.WriteLine(scope.Resolve<ShellSettings>().Name);
                        });


                    Console.WriteLine("Cycle ends.");
                    Console.WriteLine();
                }
            }

            Console.WriteLine("=== Loop sample ended === ");
        }
コード例 #3
0
        static void Main(string[] args)
        {
            Task.Run(async () =>
                {
                    // There are a lot of settings you can use.
                    var settings = new AppHostSettings
                    {
                        // A random App_Data folder so the setup sample can run from a fresh state.
                        AppDataFolderPath = "~/App_Data" + new Random().Next(),
                        ModuleFolderPaths = new[] { @"~/../../../Orchard/src/Orchard.Web/Modules" },
                        CoreModuleFolderPaths = new[] { @"~/../../../Orchard/src/Orchard.Web/Core" },
                        ThemeFolderPaths = new[] { @"~/../../../Orchard/src/Orchard.Web/Themes" },
                        ImportedExtensions = new[] { typeof(Program).Assembly },
                        DefaultShellFeatureStates = new[]
                        {
                            new DefaultShellFeatureState
                            {
                                ShellName = ShellSettings.DefaultName,
                                EnabledFeatures = new[]
                                {
                                    "Lombiq.OrchardAppHost.Sample",
                                    "Lombiq.OrchardAppHost.Sample.ShellEvents"
                                }
                            }
                        },
                        DisableConfiguratonCaches = true,
                        DisableExtensionMonitoring = true,
                        // Configuring the logging of SQL queries (see:
                        // http://weblogs.asp.net/bleroy/logging-sql-queries-in-orchard).
                        // This needs a reference to the Log4Net assembly.
                        Log4NetConfigurator = loggerRespository =>
                            ((Logger)loggerRespository.GetLogger("NHibernate.SQL")).Level = Level.Debug
                    };

                    // Samples are being run below, check out the static classes.

                    await SetupSample.RunSample(settings);
                    Console.WriteLine();
                    await LoopSample.RunSample(settings);
                    Console.WriteLine();
                    await TransientHostSample.RunSample(settings);

                    Console.ReadKey();
                }).Wait(); // This is a workaround just to be able to run all this from inside a console app.
        }
コード例 #4
0
        /// <summary>
        /// Creates and starts a persistence-less App Host that doesn't have a database connection. A transient host is very light-weight and
        /// although its state is not persisted (the Orchard shell state; any persistence you do will work of course) it's kept until the
        /// Host is disposed. That means you can still enabled/disable features for example and the shell state will change as expected.
        /// </summary>
        /// <param name="settings">Settings for the App Host.</param>
        /// <param name="registrations">Dependency registrations for the App Host.</param>
        /// <param name="enabledStartupFeatures">Names of features to enable already when the shell starts.</param>
        public static Task<IOrchardAppHost> StartTransientHost(AppHostSettings settings, AppHostRegistrations registrations, IEnumerable<ShellFeature> enabledStartupFeatures)
        {
            if (registrations == null) registrations = new AppHostRegistrations();

            var appRegistrations = (registrations.HostRegistrations == null) ? builder => { } : registrations.HostRegistrations;
            registrations.HostRegistrations = builder =>
                {
                    var shellSettingsManager = new TransientShellSettingsManager();
                    shellSettingsManager.SaveSettings(new ShellSettings { Name = ShellSettings.DefaultName, State = TenantState.Running });
                    builder.RegisterInstance(shellSettingsManager).As<IShellSettingsManager>().SingleInstance();

                    builder.RegisterType<HostTransientStore>().As<IHostTransientStore>().SingleInstance();

                    appRegistrations(builder);
                };

            var shellRegistrations = (registrations.ShellRegistrations == null) ? builder => { } : registrations.ShellRegistrations;
            registrations.ShellRegistrations = builder =>
            {
                if (enabledStartupFeatures == null) enabledStartupFeatures = Enumerable.Empty<ShellFeature>();
                enabledStartupFeatures = enabledStartupFeatures.Union(new[]
                {
                    new ShellFeature { Name = "Orchard.Framework" },
                    new ShellFeature { Name = "Lombiq.OrchardAppHost.TransientHost" }
                });

                builder
                    .RegisterInstance(new DefaultTransientShellDescriptorProvider(new ShellDescriptor { Features = enabledStartupFeatures }))
                    .As<IDefaultTransientShellDescriptorProvider>();

                builder.RegisterType<TransientShellDescriptorManager>().As<IShellDescriptorManager>().SingleInstance();
                builder.RegisterType<TransientShellStateManager>().As<IShellStateManager>().SingleInstance();
                builder.RegisterType<TransientStore>().As<ITransientStore>().SingleInstance();

                // These below are only needed if Core extensions are not loaded (i.e. their path not set in AppHostSettings).
                // Needed too early in ShellContextFactory, since the minimum shell doesn't include any external feautures.
                builder.RegisterType<NullSiteService>().As<ISiteService>().SingleInstance();
                builder.RegisterType<NullContentDefinitionManager>().As<IContentDefinitionManager>().SingleInstance();

                shellRegistrations(builder);
            };

            return StartHost(settings, registrations);
        }
コード例 #5
0
        public static async Task RunSample(AppHostSettings settings)
        {
            Console.WriteLine("=== Transient host sample starts === ");

            using (var host = await OrchardAppHostFactory.StartTransientHost(settings, null, null))
            {
                await host.Run<ITestService, ILoggerService, IClock>((testService, logger, clock) => Task.Run(() =>
                    {
                        testService.Test(); // Custom dependencies from imported and enabled extensions work too.
                        logger.Error("Test log entry from transient shell.");
                        Console.WriteLine(clock.UtcNow.ToString());
                    }));

                // You can even run such "getters" to just fetch something from Orchard.
                var utcNow = await host.RunGet(scope => Task.Run(() => scope.Resolve<IClock>().UtcNow));
            }

            Console.WriteLine("=== Transient host sample ended === ");
        }
コード例 #6
0
        public static async Task RunSample(AppHostSettings settings)
        {
            Console.WriteLine("=== Setup sample starts === ");

            using (var host = await OrchardAppHostFactory.StartHost(settings))
            {
                // We can even run the setup on a new shell. A project reference to Orchard.Setup is needed.
                // The setup shouldn't run in a transaction.
                await host.Run<ISetupService, ShellSettings>((setupService, shellSettings) => Task.Run(() =>
                    {
                        Console.WriteLine("Running setup for the following shell: " + shellSettings.Name);
                        setupService.Setup(new SetupContext
                        {
                            SiteName = "Test",
                            AdminUsername = "******",
                            AdminPassword = "******",
                            DatabaseProvider = "SqlCe",
                            Recipe = setupService.Recipes().Where(recipe => recipe.Name == "Default").Single()
                        });

                        Console.WriteLine("Setup done");
                    }), wrapInTransaction: false);
            }

            using (var host = await OrchardAppHostFactory.StartHost(settings))
            {
                // After setup everything else should be run in a newly started host.
                await host.Run<ISiteService, ShellSettings>((siteService, shellSettings) => Task.Run(() =>
                {
                    Console.WriteLine(siteService.GetSiteSettings().SiteName);
                    Console.WriteLine(shellSettings.Name);
                }));
            }

            Console.WriteLine("=== Setup host sample ended === ");
        }
コード例 #7
0
 /// <summary>
 /// Creates and starts an App Host.
 /// </summary>
 /// <param name="settings">Settings for the App Host.</param>
 /// <param name="registrations">Dependency registrations for the App Host.</param>
 public static async Task<IOrchardAppHost> StartHost(AppHostSettings settings, AppHostRegistrations registrations)
 {
     var host = new OrchardAppHost(settings, registrations);
     await host.Startup();
     return host;
 }
コード例 #8
0
 /// <summary>
 /// Creates and starts an App Host.
 /// </summary>
 /// <param name="settings">Settings for the App Host.</param>
 public static Task<IOrchardAppHost> StartHost(AppHostSettings settings)
 {
     return StartHost(settings, null);
 }
コード例 #9
0
 public ExtensionPathsProvider(AppHostSettings hostSettings, IVirtualPathProvider virtualPathProvider)
 {
     _hostSettings = hostSettings;
     _virtualPathProvider = virtualPathProvider;
 }
コード例 #10
0
 // Having an overload without "registrations" enables calling it without the caller having a reference to Autofac.
 public OrchardAppHost(AppHostSettings settings)
     : this(settings, null)
 {
 }