private Track(int key, CsvReader csvReader) { Key = key; FileName = csvReader.ReadString(); FullFileName = csvReader.ReadString(); var locationKey = csvReader.ReadInt(); Location = DC.Data._Locations.GetItem(locationKey) ?? Location.NoLocation; Title = csvReader.ReadStringNull(); TitleLowerCase = Title?.ToLowerInvariant(); Duration = csvReader.ReadTimeNull(); Album = csvReader.ReadStringNull(); AlbumLowerCase = Album?.ToLowerInvariant(); AlbumTrack = csvReader.ReadIntNull(); Artists = csvReader.ReadStringNull(); ArtistsLowerCase = Artists?.ToLowerInvariant(); Composers = csvReader.ReadStringNull(); ComposersLowerCase = Composers?.ToLowerInvariant(); Publisher = csvReader.ReadStringNull(); PublisherLowerCase = Publisher?.ToLowerInvariant(); Year = csvReader.ReadIntNull(); Genres = csvReader.ReadStringNull(); Weight = csvReader.ReadIntNull(); Volume = csvReader.ReadIntNull(); SkipStart = csvReader.ReadIntNull(); SkipEnd = csvReader.ReadIntNull(); TitleArtists = csvReader.ReadString(); DC.Data._TracksByTitleArtists.Add(TitleArtists, this); playlistTracks = new StorageList <PlaylistTrack>(); if (Location != Location.NoLocation) { Location.AddToTracks(this); } onCsvConstruct(); }
public void WeakDependencies() { var register = MockRegister(); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = new[] { typeof(Composer10) }; var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); composers.Compose(); Assert.AreEqual(1, Composed.Count); Assert.AreEqual(typeof(Composer10), Composed[0]); types = new[] { typeof(Composer11) }; composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); Assert.Throws <Exception>(() => composers.Compose()); types = new[] { typeof(Composer2) }; composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); Assert.Throws <Exception>(() => composers.Compose()); types = new[] { typeof(Composer12) }; composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); composers.Compose(); Assert.AreEqual(1, Composed.Count); Assert.AreEqual(typeof(Composer12), Composed[0]); }
/// <summary> /// Populates the object with metadata from the taglib file object /// </summary> protected override void PopulateMediaMetadata() { if (!string.IsNullOrEmpty(Path)) { // try to create the file object TagLib.File file = null; try { file = TagLib.File.Create(Path); } catch { } // if the file obj was successfully created, get data from it if (file != null) { Artists.AddRange(file.Tag.AlbumArtists); Album = file.Tag.Album; Genres.AddRange(file.Tag.Genres); Composers.AddRange(file.Tag.Composers); Title = file.Tag.Title; Year = file.Tag.Year; Track = file.Tag.Track; Disc = file.Tag.Disc; Duration = file.Properties.Duration; Lyrics = file.Tag.Lyrics; Comment = file.Tag.Comment; } } }
public void Initialize() { Composed.Clear(); Initialized.Clear(); Terminated.Clear(); var register = MockRegister(); var factory = MockFactory(m => { m.Setup(x => x.TryGetInstance(It.Is <Type>(t => t == typeof(ISomeResource)))).Returns(() => new SomeResource()); m.Setup(x => x.GetInstance(It.IsAny <Type>())).Returns <Type>((type) => { if (type == typeof(Composer1)) { return(new Composer1()); } if (type == typeof(Composer5)) { return(new Composer5()); } if (type == typeof(Component5)) { return(new Component5(new SomeResource())); } if (type == typeof(IProfilingLogger)) { return(new ProfilingLogger(Mock.Of <ILogger>(), Mock.Of <IProfiler>())); } throw new NotSupportedException(type.FullName); }); }); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = new[] { typeof(Composer1), typeof(Composer5) }; var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Assert.IsEmpty(Composed); composers.Compose(); AssertTypeArray(TypeArray <Composer1, Composer5>(), Composed); var builder = composition.WithCollectionBuilder <ComponentCollectionBuilder>(); builder.RegisterWith(register); var components = builder.CreateCollection(factory); Assert.IsEmpty(Initialized); components.Initialize(); AssertTypeArray(TypeArray <Component5>(), Initialized); Assert.IsEmpty(Terminated); components.Terminate(); AssertTypeArray(TypeArray <Component5>(), Terminated); }
public void Boot1A() { var register = MockRegister(); var typeLoader = MockTypeLoader(); var composition = new Composition(register, typeLoader, Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = TypeArray <Composer1, Composer2, Composer3, Composer4>(); var composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>()); Composed.Clear(); // 2 is Core and requires 4 // 3 is User - goes away with RuntimeLevel.Unknown // => reorder components accordingly composers.Compose(); AssertTypeArray(TypeArray <Composer1, Composer4, Composer2>(), Composed); var factory = MockFactory(m => { m.Setup(x => x.TryGetInstance(It.Is <Type>(t => t == typeof(ISomeResource)))).Returns(() => new SomeResource()); m.Setup(x => x.GetInstance(It.IsAny <Type>())).Returns <Type>((type) => { if (type == typeof(Composer1)) { return(new Composer1()); } if (type == typeof(Composer5)) { return(new Composer5()); } if (type == typeof(Component5)) { return(new Component5(new SomeResource())); } if (type == typeof(IProfilingLogger)) { return(new ProfilingLogger(Mock.Of <ILogger>(), Mock.Of <IProfiler>())); } throw new NotSupportedException(type.FullName); }); }); var builder = composition.WithCollectionBuilder <ComponentCollectionBuilder>(); builder.RegisterWith(register); var components = builder.CreateCollection(factory); Assert.IsEmpty(components); components.Initialize(); Assert.IsEmpty(Initialized); components.Terminate(); Assert.IsEmpty(Terminated); }
public void Requires1() { var register = MockRegister(); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = new[] { typeof(Composer6), typeof(Composer7), typeof(Composer8) }; var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); composers.Compose(); Assert.AreEqual(2, Composed.Count); Assert.AreEqual(typeof(Composer6), Composed[0]); Assert.AreEqual(typeof(Composer8), Composed[1]); }
public void Boot2() { var register = MockRegister(); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = TypeArray <Composer20, Composer21>(); var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); // 21 is required by 20 // => reorder components accordingly composers.Compose(); AssertTypeArray(TypeArray <Composer21, Composer20>(), Composed); }
public void DisableMissing() { var register = MockRegister(); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = new[] { typeof(Composer6), typeof(Composer8) }; // 8 disables 7 which is not in the list var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); composers.Compose(); Assert.AreEqual(2, Composed.Count); Assert.AreEqual(typeof(Composer6), Composed[0]); Assert.AreEqual(typeof(Composer8), Composed[1]); }
public void Requires2A() { var register = MockRegister(); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = new[] { typeof(Composer9), typeof(Composer2), typeof(Composer4) }; var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); composers.Compose(); Assert.AreEqual(2, Composed.Count); Assert.AreEqual(typeof(Composer4), Composed[0]); Assert.AreEqual(typeof(Composer2), Composed[1]); //Assert.AreEqual(typeof(Component9), Composed[2]); -- goes away with RuntimeLevel.Unknown }
public void Boot1B() { var register = MockRegister(); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Run)); var types = TypeArray <Composer1, Composer2, Composer3, Composer4>(); var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); // 2 is Core and requires 4 // 3 is User - stays with RuntimeLevel.Run // => reorder components accordingly composers.Compose(); AssertTypeArray(TypeArray <Composer1, Composer4, Composer2, Composer3>(), Composed); }
public void Boot3() { var register = MockRegister(); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = TypeArray <Composer22, Composer24, Composer25>(); var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); // i23 requires 22 // 24, 25 implement i23 // 25 required by i23 // => reorder components accordingly composers.Compose(); AssertTypeArray(TypeArray <Composer22, Composer25, Composer24>(), Composed); }
public void BrokenRequired() { var register = MockRegister(); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = TypeArray <Composer2, Composer4, Composer13>(); var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); // 2 is Core and requires 4 // 13 is required by 1 // 1 is missing // => reorder components accordingly composers.Compose(); AssertTypeArray(TypeArray <Composer4, Composer2, Composer13>(), Composed); }
public void AllComposers() { var typeLoader = new TypeLoader(AppCaches.Disabled.RuntimeCache, IOHelper.MapPath("~/App_Data/TEMP"), Mock.Of <IProfilingLogger>()); var register = MockRegister(); var composition = new Composition(register, typeLoader, Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Run)); var types = typeLoader.GetTypes <IComposer>().Where(x => x.FullName.StartsWith("Umbraco.Core.") || x.FullName.StartsWith("Umbraco.Web")); var composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>()); var requirements = composers.GetRequirements(); var report = Composers.GetComposersReport(requirements); Console.WriteLine(report); var composerTypes = composers.SortComposers(requirements); foreach (var type in composerTypes) { Console.WriteLine(type); } }
public void AttributesPriorities() { var register = MockRegister(); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = new[] { typeof(Composer26) }; // 26 disabled by assembly attribute var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); composers.Compose(); Assert.AreEqual(0, Composed.Count); // 26 gone types = new[] { typeof(Composer26), typeof(Composer27) }; // 26 disabled by assembly attribute, enabled by 27 composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); composers.Compose(); Assert.AreEqual(2, Composed.Count); // both Assert.AreEqual(typeof(Composer26), Composed[0]); Assert.AreEqual(typeof(Composer27), Composed[1]); }
public void Requires2B() { var register = MockRegister(); var factory = MockFactory(); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Run)); var types = new[] { typeof(Composer9), typeof(Composer2), typeof(Composer4) }; var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); composers.Compose(); var builder = composition.WithCollectionBuilder <ComponentCollectionBuilder>(); builder.RegisterWith(register); var components = builder.CreateCollection(factory); Assert.AreEqual(3, Composed.Count); Assert.AreEqual(typeof(Composer4), Composed[0]); Assert.AreEqual(typeof(Composer2), Composed[1]); Assert.AreEqual(typeof(Composer9), Composed[2]); }
public void WeakDependencies() { var register = MockRegister(); var typeLoader = MockTypeLoader(); var composition = new Composition(register, typeLoader, Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = new[] { typeof(Composer10) }; var composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>()); Composed.Clear(); composers.Compose(); Assert.AreEqual(1, Composed.Count); Assert.AreEqual(typeof(Composer10), Composed[0]); types = new[] { typeof(Composer11) }; composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>()); Composed.Clear(); Assert.Throws <Exception>(() => composers.Compose()); Console.WriteLine("throws:"); composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>()); var requirements = composers.GetRequirements(false); Console.WriteLine(Composers.GetComposersReport(requirements)); types = new[] { typeof(Composer2) }; composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>()); Composed.Clear(); Assert.Throws <Exception>(() => composers.Compose()); Console.WriteLine("throws:"); composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>()); requirements = composers.GetRequirements(false); Console.WriteLine(Composers.GetComposersReport(requirements)); types = new[] { typeof(Composer12) }; composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>()); Composed.Clear(); composers.Compose(); Assert.AreEqual(1, Composed.Count); Assert.AreEqual(typeof(Composer12), Composed[0]); }
public void BrokenRequire() { var register = MockRegister(); var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown)); var types = TypeArray <Composer1, Composer2, Composer3>(); var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>()); Composed.Clear(); try { // 2 is Core and requires 4 // 4 is missing // => throw composers.Compose(); Assert.Fail("Expected exception."); } catch (Exception e) { Assert.AreEqual("Broken composer dependency: Umbraco.Tests.Components.ComponentTests+Composer2 -> Umbraco.Tests.Components.ComponentTests+Composer4.", e.Message); } }
public override Task NavigatedToAsync(object parameter = null) { return(Task.Factory.StartNew(async() => { do { await Task.Delay(100); } while (ComposerList.Count == 0); Device.BeginInvokeOnMainThread(() => { if (Device.RuntimePlatform.Equals(Device.iOS)) //iOS { if (ComposerSimpleList.Any()) { return; } ComposerSimpleList.AddRange(ComposerList); } else { if (Composers.Any()) { return; } var groups = ComposerList.GroupBy(x => x.Name.First().ToString()); foreach (var group in groups) { var coll = new ComposerGroup(); coll.AddRange(group); coll.ShortName = group.Key; Composers.Add(coll); } } }); })); }
public void StandaloneTest() { IFactory factory = null; // clear foreach (var file in Directory.GetFiles(Path.Combine(IOHelper.MapPath("~/App_Data")), "NuCache.*")) { File.Delete(file); } // settings // reset the current version to 0.0.0, clear connection strings ConfigurationManager.AppSettings[Constants.AppSettings.ConfigurationStatus] = ""; // FIXME: we need a better management of settings here (and, true config files?) // create the very basic and essential things we need var logger = new ConsoleLogger(); var profiler = new LogProfiler(logger); var profilingLogger = new ProfilingLogger(logger, profiler); var appCaches = new AppCaches(); // FIXME: has HttpRuntime stuff? var databaseFactory = new UmbracoDatabaseFactory(logger, new Lazy <IMapperCollection>(() => factory.GetInstance <IMapperCollection>())); var typeLoader = new TypeLoader(appCaches.RuntimeCache, IOHelper.MapPath("~/App_Data/TEMP"), profilingLogger); var mainDom = new SimpleMainDom(); var runtimeState = new RuntimeState(logger, null, null, new Lazy <IMainDom>(() => mainDom), new Lazy <IServerRegistrar>(() => factory.GetInstance <IServerRegistrar>())); // create the register and the composition var register = RegisterFactory.Create(); var composition = new Composition(register, typeLoader, profilingLogger, runtimeState); composition.RegisterEssentials(logger, profiler, profilingLogger, mainDom, appCaches, databaseFactory, typeLoader, runtimeState); // create the core runtime and have it compose itself var coreRuntime = new CoreRuntime(); coreRuntime.Compose(composition); // determine actual runtime level runtimeState.DetermineRuntimeLevel(databaseFactory, logger); Console.WriteLine(runtimeState.Level); // going to be Install BUT we want to force components to be there (nucache etc) runtimeState.Level = RuntimeLevel.Run; var composerTypes = typeLoader.GetTypes <IComposer>() // all of them .Where(x => !x.FullName.StartsWith("Umbraco.Tests.")) // exclude test components .Where(x => x != typeof(WebInitialComposer) && x != typeof(WebFinalComposer)); // exclude web runtime var composers = new Composers(composition, composerTypes, Enumerable.Empty <Attribute>(), profilingLogger); composers.Compose(); // must registers stuff that WebRuntimeComponent would register otherwise // FIXME: UmbracoContext creates a snapshot that it does not register with the accessor // and so, we have to use the UmbracoContextPublishedSnapshotAccessor // the UmbracoContext does not know about the accessor // else that would be a catch-22 where they both know about each other? //composition.Register<IPublishedSnapshotAccessor, TestPublishedSnapshotAccessor>(Lifetime.Singleton); composition.Register <IPublishedSnapshotAccessor, UmbracoContextPublishedSnapshotAccessor>(Lifetime.Singleton); composition.Register <IUmbracoContextAccessor, TestUmbracoContextAccessor>(Lifetime.Singleton); composition.Register <IVariationContextAccessor, TestVariationContextAccessor>(Lifetime.Singleton); composition.Register <IDefaultCultureAccessor, TestDefaultCultureAccessor>(Lifetime.Singleton); composition.Register <ISiteDomainHelper>(_ => Mock.Of <ISiteDomainHelper>(), Lifetime.Singleton); composition.Register(_ => Mock.Of <IImageUrlGenerator>(), Lifetime.Singleton); composition.RegisterUnique(f => new DistributedCache()); composition.WithCollectionBuilder <UrlProviderCollectionBuilder>().Append <DefaultUrlProvider>(); composition.RegisterUnique <IDistributedCacheBinder, DistributedCacheBinder>(); composition.RegisterUnique <IExamineManager>(f => ExamineManager.Instance); composition.RegisterUnique <IUmbracoContextFactory, UmbracoContextFactory>(); composition.RegisterUnique <IMacroRenderer, MacroRenderer>(); composition.RegisterUnique <MediaUrlProviderCollection>(_ => new MediaUrlProviderCollection(Enumerable.Empty <IMediaUrlProvider>())); // initialize some components only/individually composition.WithCollectionBuilder <ComponentCollectionBuilder>() .Clear() .Append <DistributedCacheBinderComponent>(); // configure composition.Configs.Add(SettingsForTests.GetDefaultGlobalSettings); composition.Configs.Add(SettingsForTests.GetDefaultUmbracoSettings); // create and register the factory Current.Factory = factory = composition.CreateFactory(); // instantiate and initialize components var components = factory.GetInstance <ComponentCollection>(); // do stuff Console.WriteLine(runtimeState.Level); // install if (true || runtimeState.Level == RuntimeLevel.Install) { var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); var file = databaseFactory.Configured ? Path.Combine(path, "UmbracoNPocoTests.sdf") : Path.Combine(path, "Umbraco.sdf"); if (File.Exists(file)) { File.Delete(file); } // create the database file // databaseBuilder.ConfigureEmbeddedDatabaseConnection() can do it too, // but then it wants to write the connection string to web.config = bad var connectionString = databaseFactory.Configured ? databaseFactory.ConnectionString : "Data Source=|DataDirectory|\\Umbraco.sdf;Flush Interval=1;"; using (var engine = new SqlCeEngine(connectionString)) { engine.CreateDatabase(); } //var databaseBuilder = factory.GetInstance<DatabaseBuilder>(); //databaseFactory.Configure(DatabaseBuilder.EmbeddedDatabaseConnectionString, Constants.DbProviderNames.SqlCe); //databaseBuilder.CreateDatabaseSchemaAndData(); if (!databaseFactory.Configured) { databaseFactory.Configure(DatabaseBuilder.EmbeddedDatabaseConnectionString, Constants.DbProviderNames.SqlCe); } var scopeProvider = factory.GetInstance <IScopeProvider>(); using (var scope = scopeProvider.CreateScope()) { var creator = new DatabaseSchemaCreator(scope.Database, logger); creator.InitializeDatabaseSchema(); scope.Complete(); } } // done installing runtimeState.Level = RuntimeLevel.Run; components.Initialize(); // instantiate to register events // should be done by Initialize? // should we invoke Initialize? _ = factory.GetInstance <IPublishedSnapshotService>(); // at that point, Umbraco can run! // though, we probably still need to figure out what depends on HttpContext... var contentService = factory.GetInstance <IContentService>(); var content = contentService.GetById(1234); Assert.IsNull(content); // create a document type and a document var contentType = new ContentType(-1) { Alias = "ctype", Name = "ctype" }; factory.GetInstance <IContentTypeService>().Save(contentType); content = new Content("test", -1, contentType); contentService.Save(content); // assert that it is possible to get the document back content = contentService.GetById(content.Id); Assert.IsNotNull(content); Assert.AreEqual("test", content.Name); // need an UmbracoCOntext to access the cache // FIXME: not exactly pretty, should not depend on HttpContext var httpContext = Mock.Of <HttpContextBase>(); var umbracoContextFactory = factory.GetInstance <IUmbracoContextFactory>(); var umbracoContextReference = umbracoContextFactory.EnsureUmbracoContext(httpContext); var umbracoContext = umbracoContextReference.UmbracoContext; // assert that there is no published document var pcontent = umbracoContext.Content.GetById(content.Id); Assert.IsNull(pcontent); // but a draft document pcontent = umbracoContext.Content.GetById(true, content.Id); Assert.IsNotNull(pcontent); Assert.AreEqual("test", pcontent.Name()); Assert.IsTrue(pcontent.IsDraft()); // no published URL Assert.AreEqual("#", pcontent.Url()); // now publish the document + make some unpublished changes contentService.SaveAndPublish(content); content.Name = "testx"; contentService.Save(content); // assert that snapshot has been updated and there is now a published document pcontent = umbracoContext.Content.GetById(content.Id); Assert.IsNotNull(pcontent); Assert.AreEqual("test", pcontent.Name()); Assert.IsFalse(pcontent.IsDraft()); // but the URL is the published one - no draft URL Assert.AreEqual("/test/", pcontent.Url()); // and also an updated draft document pcontent = umbracoContext.Content.GetById(true, content.Id); Assert.IsNotNull(pcontent); Assert.AreEqual("testx", pcontent.Name()); Assert.IsTrue(pcontent.IsDraft()); // and the published document has a URL Assert.AreEqual("/test/", pcontent.Url()); umbracoContextReference.Dispose(); mainDom.Stop(); components.Terminate(); // exit! }
public void ValidateComposition() { // this is almost what CoreRuntime does, without // - managing MainDom // - configuring for unhandled exceptions, assembly resolution, application root path // - testing for database, and for upgrades (runtime level) // - assigning the factory to Current.Factory // create the very basic and essential things we need var logger = new ConsoleLogger(); var profiler = Mock.Of <IProfiler>(); var profilingLogger = new ProfilingLogger(logger, profiler); var appCaches = AppCaches.Disabled; var databaseFactory = Mock.Of <IUmbracoDatabaseFactory>(); var typeLoader = new TypeLoader(appCaches.RuntimeCache, IOHelper.MapPath("~/App_Data/TEMP"), profilingLogger); var runtimeState = Mock.Of <IRuntimeState>(); Mock.Get(runtimeState).Setup(x => x.Level).Returns(RuntimeLevel.Run); var mainDom = Mock.Of <IMainDom>(); Mock.Get(mainDom).Setup(x => x.IsMainDom).Returns(true); // create the register and the composition var register = RegisterFactory.Create(); var composition = new Composition(register, typeLoader, profilingLogger, runtimeState); composition.RegisterEssentials(logger, profiler, profilingLogger, mainDom, appCaches, databaseFactory, typeLoader, runtimeState); // create the core runtime and have it compose itself var coreRuntime = new CoreRuntime(); coreRuntime.Compose(composition); // get the components // all of them? var composerTypes = typeLoader.GetTypes <IComposer>(); // filtered composerTypes = composerTypes .Where(x => !x.FullName.StartsWith("Umbraco.Tests")); // single? //var componentTypes = new[] { typeof(CoreRuntimeComponent) }; var composers = new Composers(composition, composerTypes, Enumerable.Empty <Attribute>(), profilingLogger); // get components to compose themselves composers.Compose(); // create the factory var factory = composition.CreateFactory(); // at that point Umbraco is fully composed // but nothing is initialized (no maindom, nothing - beware!) // to actually *run* Umbraco standalone, better use a StandaloneRuntime // that would inherit from CoreRuntime and ensure everything starts // get components to initialize themselves //components.Initialize(factory); // and then, validate var lightInjectContainer = (LightInject.ServiceContainer)factory.Concrete; var results = lightInjectContainer.Validate().ToList(); foreach (var resultGroup in results.GroupBy(x => x.Severity).OrderBy(x => x.Key)) { Console.WriteLine($"{resultGroup.Key}: {resultGroup.Count()}"); } foreach (var resultGroup in results.GroupBy(x => x.Severity).OrderBy(x => x.Key)) { foreach (var result in resultGroup) { Console.WriteLine(); Console.Write(ToText(result)); } } Assert.AreEqual(0, results.Count); }
/// <summary> /// Boots the runtime within a timer. /// </summary> protected virtual IFactory Boot(IRegister register, DisposableTimer timer) { Composition composition = null; try { // Setup event listener UnattendedInstalled += CoreRuntime_UnattendedInstalled; // throws if not full-trust new AspNetHostingPermission(AspNetHostingPermissionLevel.Unrestricted).Demand(); // run handlers RuntimeOptions.DoRuntimeBoot(ProfilingLogger); // application caches var appCaches = GetAppCaches(); // database factory var databaseFactory = GetDatabaseFactory(); // configs var configs = GetConfigs(); // type loader var typeLoader = new TypeLoader(appCaches.RuntimeCache, configs.Global().LocalTempPath, ProfilingLogger); // runtime state // beware! must use '() => _factory.GetInstance<T>()' and NOT '_factory.GetInstance<T>' // as the second one captures the current value (null) and therefore fails _state = new RuntimeState(Logger, configs.Settings(), configs.Global(), new Lazy <IMainDom>(() => _factory.GetInstance <IMainDom>()), new Lazy <IServerRegistrar>(() => _factory.GetInstance <IServerRegistrar>())) { Level = RuntimeLevel.Boot }; // TODO: remove this in netcore, this is purely backwards compat hacks with the empty ctor if (MainDom == null) { MainDom = new MainDom(Logger, new MainDomSemaphoreLock(Logger)); } // create the composition composition = new Composition(register, typeLoader, ProfilingLogger, _state, configs); composition.RegisterEssentials(Logger, Profiler, ProfilingLogger, MainDom, appCaches, databaseFactory, typeLoader, _state); // run handlers RuntimeOptions.DoRuntimeEssentials(composition, appCaches, typeLoader, databaseFactory); // register runtime-level services // there should be none, really - this is here "just in case" Compose(composition); // acquire the main domain - if this fails then anything that should be registered with MainDom will not operate AcquireMainDom(MainDom); // determine our runtime level DetermineRuntimeLevel(databaseFactory, ProfilingLogger); // get composers, and compose var composerTypes = ResolveComposerTypes(typeLoader); IEnumerable <Attribute> enableDisableAttributes; using (ProfilingLogger.DebugDuration <CoreRuntime>("Scanning enable/disable composer attributes")) { enableDisableAttributes = typeLoader.GetAssemblyAttributes(typeof(EnableComposerAttribute), typeof(DisableComposerAttribute)); } var composers = new Composers(composition, composerTypes, enableDisableAttributes, ProfilingLogger); composers.Compose(); // create the factory _factory = Current.Factory = composition.CreateFactory(); // determines if unattended install is enabled and performs it if required DoUnattendedInstall(databaseFactory); // determine our runtime level (AFTER UNATTENDED INSTALL) // TODO: Feels kinda weird to call this again DetermineRuntimeLevel(databaseFactory, ProfilingLogger); // if level is Run and reason is UpgradeMigrations, that means we need to perform an unattended upgrade if (_state.Reason == RuntimeLevelReason.UpgradeMigrations && _state.Level == RuntimeLevel.Run) { // do the upgrade DoUnattendedUpgrade(_factory.GetInstance <DatabaseBuilder>()); // upgrade is done, set reason to Run _state.Reason = RuntimeLevelReason.Run; } // create & initialize the components _components = _factory.GetInstance <ComponentCollection>(); _components.Initialize(); } catch (Exception e) { var bfe = e as BootFailedException ?? new BootFailedException("Boot failed.", e); if (_state != null) { _state.Level = RuntimeLevel.BootFailed; _state.BootFailedException = bfe; } timer?.Fail(exception: bfe); // be sure to log the exception - even if we repeat ourselves // if something goes wrong above, we may end up with no factory // meaning nothing can get the runtime state, etc - so let's try // to make sure we have a factory if (_factory == null) { try { _factory = Current.Factory = composition?.CreateFactory(); } catch { // In this case we are basically dead, we do not have a factory but we need // to report on the state so we need to manually set that, this is the only time // we ever do this. Current.RuntimeState = _state; } } Debugger.Break(); // throwing here can cause w3wp to hard-crash and we want to avoid it. // instead, we're logging the exception and setting level to BootFailed. // various parts of Umbraco such as UmbracoModule and UmbracoDefaultOwinStartup // understand this and will nullify themselves, while UmbracoModule will // throw a BootFailedException for every requests. } return(_factory); }
private void CloseIconPressedLoreItem() { Composers.Remove("loreItem"); }
/// <summary> /// Boots the runtime within a timer. /// </summary> protected virtual IFactory Boot(IRegister register, DisposableTimer timer) { Composition composition = null; try { // throws if not full-trust new AspNetHostingPermission(AspNetHostingPermissionLevel.Unrestricted).Demand(); // application caches var appCaches = GetAppCaches(); var runtimeCache = appCaches.RuntimeCache; // database factory var databaseFactory = GetDatabaseFactory(); // configs var configs = GetConfigs(); // type loader var localTempStorage = configs.Global().LocalTempStorageLocation; var typeLoader = new TypeLoader(runtimeCache, localTempStorage, ProfilingLogger); // runtime state // beware! must use '() => _factory.GetInstance<T>()' and NOT '_factory.GetInstance<T>' // as the second one captures the current value (null) and therefore fails _state = new RuntimeState(Logger, configs.Settings(), configs.Global(), new Lazy <IMainDom>(() => _factory.GetInstance <IMainDom>()), new Lazy <IServerRegistrar>(() => _factory.GetInstance <IServerRegistrar>())) { Level = RuntimeLevel.Boot }; // main dom var mainDom = new MainDom(Logger); // create the composition composition = new Composition(register, typeLoader, ProfilingLogger, _state, configs); composition.RegisterEssentials(Logger, Profiler, ProfilingLogger, mainDom, appCaches, databaseFactory, typeLoader, _state); // register runtime-level services // there should be none, really - this is here "just in case" Compose(composition); // acquire the main domain, determine our runtime level AcquireMainDom(mainDom); DetermineRuntimeLevel(databaseFactory, ProfilingLogger); // get composers, and compose var composerTypes = ResolveComposerTypes(typeLoader); composition.WithCollectionBuilder <ComponentCollectionBuilder>(); var composers = new Composers(composition, composerTypes, ProfilingLogger); composers.Compose(); // create the factory _factory = Current.Factory = composition.CreateFactory(); // create & initialize the components _components = _factory.GetInstance <ComponentCollection>(); _components.Initialize(); } catch (Exception e) { var bfe = e as BootFailedException ?? new BootFailedException("Boot failed.", e); if (_state != null) { _state.Level = RuntimeLevel.BootFailed; _state.BootFailedException = bfe; } timer.Fail(exception: bfe); // be sure to log the exception - even if we repeat ourselves // if something goes wrong above, we may end up with no factory // meaning nothing can get the runtime state, etc - so let's try // to make sure we have a factory if (_factory == null) { try { _factory = Current.Factory = composition?.CreateFactory(); } catch { /* yea */ } } Debugger.Break(); // throwing here can cause w3wp to hard-crash and we want to avoid it. // instead, we're logging the exception and setting level to BootFailed. // various parts of Umbraco such as UmbracoModule and UmbracoDefaultOwinStartup // understand this and will nullify themselves, while UmbracoModule will // throw a BootFailedException for every requests. } return(_factory); }