public IBeanContextHolder <I> CreateService <I>(String contextName, IBackgroundWorkerParamDelegate <IBeanContextFactory> registerPhaseDelegate, params Type[] serviceModuleTypes) { CheckNotDisposed(); IBeanContextInitializer beanContextInitializer = RegisterBean <BeanContextInitializer>().Finish(); if (contextName == null && registerPhaseDelegate == null && serviceModuleTypes.Length == 1) { contextName = serviceModuleTypes[0].Name; } BeanContextFactory childBeanContextFactory = beanContextFactory.CreateChildContextFactory(beanContextInitializer, this); IServiceContext childContext = childBeanContextFactory.Create(contextName, this, registerPhaseDelegate, serviceModuleTypes); writeLock.Lock(); try { if (children == null) { children = new IdentityHashSet <IServiceContext>(); } children.Add(childContext); } finally { writeLock.Unlock(); } return(new BeanContextHolder <I>(childContext)); }
public virtual void SetUp() { ParamChecker.AssertNull(beanContext, "Must never happen"); beanContext = BeanContextFactory.CreateBootstrap(typeof(ChildContextHandleChildFactoryTestModule)); beanContext = beanContext.CreateService(typeof(ChildContextHandleTestModule)); }
public IBeanConfiguration GetBeanConfiguration(BeanContextFactory beanContextFactory, String beanName) { CheckNotDisposed(); IBeanConfiguration beanConfiguration = beanContextFactory.GetBeanConfiguration(beanName); if (beanConfiguration == null && parent != null) { return(parent.GetBeanConfiguration(beanName)); } return(beanConfiguration); }
public void RebuildContext(MethodInfo frameworkMethod) { DisposeContext(); Properties.ResetApplication(); Properties.LoadBootstrapPropertyFile(); Properties baseProps = new Properties(Properties.Application); ExtendProperties(frameworkMethod, baseProps); LinkedHashSet <Type> testClassLevelTestFrameworkModulesList = new LinkedHashSet <Type>(); LinkedHashSet <Type> testClassLevelTestModulesList = new LinkedHashSet <Type>(); testClassLevelTestModulesList.AddAll(BuildTestModuleList(frameworkMethod)); testClassLevelTestFrameworkModulesList.AddAll(BuildFrameworkTestModuleList(frameworkMethod)); Type[] frameworkModules = testClassLevelTestFrameworkModulesList.ToArray(); Type[] applicationModules = testClassLevelTestModulesList.ToArray(); testClassLevelContext = BeanContextFactory.CreateBootstrap(baseProps); bool success = false; try { IServiceContext currentBeanContext = testClassLevelContext; if (frameworkModules.Length > 0) { currentBeanContext = currentBeanContext.CreateService(delegate(IBeanContextFactory childContextFactory) { RebuildContextDetails(childContextFactory); }, frameworkModules); } if (applicationModules.Length > 0) { currentBeanContext = currentBeanContext.CreateService(applicationModules); } currentBeanContext.RegisterWithLifecycle(originalTestInstance).Finish(); beanContext = currentBeanContext; success = true; } finally { if (!success && testClassLevelContext != null) { testClassLevelContext.GetService <IThreadLocalCleanupController>().CleanupThreadLocal(); } } }
static void Main(String[] args) { Properties.Application.FillWithCommandLineArgs(args); Properties.LoadBootstrapPropertyFile(); Properties props = Properties.Application; IServiceContext bootstrapContext = BeanContextFactory.CreateBootstrap(props, typeof(IocModule)); try { bootstrapContext.CreateService(typeof(ParserModule)); } finally { bootstrapContext.Dispose(); } }
public V Finish() { BeanContextFactory beanContextFactory = serviceContext.GetBeanContextFactory(); IBeanContextInitializer beanContextInitializer = beanContextFactory.GetBeanContextInitializer(); IList <IBeanConfiguration> beanConfHierarchy = beanContextInitializer.FillParentHierarchyIfValid(serviceContext, beanContextFactory, beanConfiguration); V bean = beanInstance; if (bean == null) { Type beanType = this.beanType; if (beanType == null) { beanType = beanContextInitializer.ResolveTypeInHierarchy(beanConfHierarchy); } bean = (V)Activator.CreateInstance(beanType); } bean = (V)beanContextInitializer.InitializeBean(serviceContext, beanContextFactory, beanConfiguration, bean, beanConfHierarchy, joinLifecycle); return(bean); }
public static IAmbethPlatformContext Create(Properties props, Type[] providerModules, Type[] frameworkModules, Type[] bootstrapModules, IInitializingModule[] providerModuleInstances, IInitializingModule[] frameworkModuleInstances, IInitializingModule[] bootstrapModuleInstances) { ParamChecker.AssertParamNotNull(props, "props"); IServiceContext bootstrapContext = null; AmbethPlatformContext apc = new AmbethPlatformContext(); try { IInitializingModule[] providerModuleInstancesCopy = new IInitializingModule[providerModuleInstances.Length + 1]; Array.Copy(providerModuleInstances, 0, providerModuleInstancesCopy, 0, providerModuleInstances.Length); providerModuleInstancesCopy[providerModuleInstancesCopy.Length - 1] = new AmbethPlatformContextModule(apc); providerModuleInstances = providerModuleInstancesCopy; bootstrapContext = BeanContextFactory.CreateBootstrap(props, providerModules, providerModuleInstances); IList <IModuleProvider> moduleProviders = bootstrapContext.GetImplementingObjects <IModuleProvider>(); for (int a = moduleProviders.Count; a-- > 0;) { IModuleProvider moduleProvider = moduleProviders[a]; Type[] mpFrameworkModules = moduleProvider.GetFrameworkModules(); Type[] mpBootstrapModules = moduleProvider.GetBootstrapModules(); frameworkModules = ModuleUtil.MergeModules(mpFrameworkModules, frameworkModules); bootstrapModules = ModuleUtil.MergeModules(mpBootstrapModules, bootstrapModules); } IServiceContext frameworkBeanContext = bootstrapContext; if (frameworkModules.Length > 0 || frameworkModuleInstances.Length > 0) { frameworkBeanContext = bootstrapContext.CreateService("framework", delegate(IBeanContextFactory childContextFactory) { for (int a = frameworkModuleInstances.Length; a-- > 0;) { childContextFactory.RegisterExternalBean(frameworkModuleInstances[a]); } }, frameworkModules); } ILightweightTransaction transaction = frameworkBeanContext.GetService <ILightweightTransaction>(false); if (transaction != null) { ILogger log = LoggerFactory.GetLogger(typeof(AmbethPlatformContext), props); if (log.InfoEnabled) { log.Info("Starting initial database transaction to receive metadata for OR-Mappings..."); } transaction.RunInTransaction(delegate() { // Intended blank }); if (log.InfoEnabled) { log.Info("Initial database transaction processed successfully"); } } IServiceContext applicationBeanContext = frameworkBeanContext; if (bootstrapModules.Length > 0 || bootstrapModuleInstances.Length > 0) { applicationBeanContext = frameworkBeanContext.CreateService("application", delegate(IBeanContextFactory childContextFactory) { for (int a = bootstrapModuleInstances.Length; a-- > 0;) { childContextFactory.RegisterExternalBean(bootstrapModuleInstances[a]); } }, bootstrapModules); } apc.beanContext = applicationBeanContext; return(apc); } catch (Exception) { if (bootstrapContext != null) { IThreadLocalCleanupController tlCleanupController = bootstrapContext.GetService <IThreadLocalCleanupController>(); bootstrapContext.Dispose(); tlCleanupController.CleanupThreadLocal(); } throw; } }
private void Application_Startup(object sender, StartupEventArgs e) { String configFolder = "config"; String fileName = "Minerva.properties"; String filePath = configFolder + "\\" + fileName; IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForSite(); Stream primaryPropertyStream = null; try { storage.CreateDirectory("config"); primaryPropertyStream = new IsolatedStorageFileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite, storage); } catch (IsolatedStorageException) { // Intended blank } catch (FileNotFoundException) { // Intended blank } String urlString = "/Minerva.Client;component/" + filePath; StreamResourceInfo streamResourceInfo = Application.GetResourceStream(new Uri(urlString, UriKind.Relative)); if (streamResourceInfo == null) { #if DEVELOP urlString = "/Minerva.Client;component/" + configFolder + "/Osthus.properties"; #else urlString = "/Minerva.Client;component/" + configFolder + "/Osthus_Production.properties"; #endif streamResourceInfo = Application.GetResourceStream(new Uri(urlString, UriKind.Relative)); } Properties properties = Properties.Application; if (streamResourceInfo != null) { properties.Load(streamResourceInfo.Stream); } String servicePort = DictionaryExtension.ValueOrDefault(e.InitParams, "serviceport"); String serviceHost = DictionaryExtension.ValueOrDefault(e.InitParams, "servicehost"); DictionaryExtension.Loop(e.InitParams, delegate(String key, String value) { properties.Set(key, value); }); if (servicePort != null) { properties[ServiceConfigurationConstants.ServiceHostPort] = servicePort; } if (serviceHost != null) { properties[ServiceConfigurationConstants.ServiceHostName] = serviceHost; } properties.Load(primaryPropertyStream); Properties.System[ServiceWCFConfigurationConstants.TransferObjectsScope] = ".+"; Properties.System[EventConfigurationConstants.PollingActive] = "true"; Properties.System[ServiceConfigurationConstants.NetworkClientMode] = "true"; Properties.System[ServiceConfigurationConstants.GenericTransferMapping] = "false"; Properties.System[ServiceConfigurationConstants.IndependentMetaData] = "false"; properties[ServiceConfigurationConstants.ServiceBaseUrl] = "${" + ServiceConfigurationConstants.ServiceProtocol + "}://" + "${" + ServiceConfigurationConstants.ServiceHostName + "}" + ":" + "${" + ServiceConfigurationConstants.ServiceHostPort + "}" + "${" + ServiceConfigurationConstants.ServicePrefix + "}"; properties[ServiceConfigurationConstants.ServiceProtocol] = "http"; properties[ServiceConfigurationConstants.ServiceHostName] = "localhost."; properties[ServiceConfigurationConstants.ServiceHostPort] = "9080"; properties[ServiceConfigurationConstants.ServicePrefix] = "/helloworld"; LoggerFactory.LoggerType = typeof(De.Osthus.Ambeth.Log.ClientLogger); Log = LoggerFactory.GetLogger(typeof(App), properties); if (Log.InfoEnabled) { ISet <String> allPropertiesSet = properties.CollectAllPropertyKeys(); List <String> allPropertiesList = new List <String>(allPropertiesSet); allPropertiesList.Sort(); Log.Info("Property environment:"); foreach (String property in allPropertiesList) { Log.Info("Property " + property + "=" + properties[property]); } } Type type = storage.GetType(); PropertyInfo propertyInfo = null; while (type != null) { propertyInfo = type.GetProperty("RootDirectory", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public); if (propertyInfo != null) { break; } type = type.BaseType; } AssemblyHelper.RegisterAssemblyFromType(typeof(BytecodeModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(CacheBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(CacheBytecodeModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(CacheDataChangeBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(DataChangeBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(EventBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(IocBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(MergeBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(CompositeIdModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(PrivilegeBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(SecurityBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(ServiceBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(MethodDescription)); AssemblyHelper.RegisterAssemblyFromType(typeof(MinervaCoreBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(RESTBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(XmlBootstrapModule)); AssemblyHelper.RegisterAssemblyFromType(typeof(FilterDescriptor)); AssemblyHelper.RegisterAssemblyFromType(typeof(HelloWorldModule)); AssemblyHelper.InitAssemblies("ambeth\\..+", "minerva\\..+"); properties[XmlConfigurationConstants.PackageScanPatterns] = @"De\.Osthus(?:\.Ambeth|\.Minerva)(?:\.[^\.]+)*(?:\.Transfer|\.Model|\.Service)\..+"; properties[CacheConfigurationConstants.FirstLevelCacheType] = "SINGLETON"; properties[CacheConfigurationConstants.OverwriteToManyRelationsInChildCache] = "false"; properties[CacheConfigurationConstants.UpdateChildCache] = "true"; properties[MinervaCoreConfigurationConstants.EntityProxyActive] = "true"; properties[ServiceConfigurationConstants.TypeInfoProviderType] = typeof(MergeTypeInfoProvider).FullName; // Set this to false, to test with mocks (offline) bool Online = true; properties[CacheConfigurationConstants.CacheServiceBeanActive] = Online.ToString(); properties[EventConfigurationConstants.EventServiceBeanActive] = Online.ToString(); properties[MergeConfigurationConstants.MergeServiceBeanActive] = Online.ToString(); properties[SecurityConfigurationConstants.SecurityServiceBeanActive] = Online.ToString(); properties[HelloWorldConfigurationConstants.HelloWorldServiceBeanActive] = Online.ToString(); properties[MergeConfigurationConstants.MergeServiceMockType] = typeof(HelloWorldMergeMock).FullName; //already default: properties[RESTConfigurationConstants.HttpAcceptEncodingZipped] = "true"; //already default: properties[RESTConfigurationConstants.HttpContentEncodingZipped] = "true"; //already default: properties[RESTConfigurationConstants.HttpUseClient] = "true"; IServiceContext bootstrapContext = BeanContextFactory.CreateBootstrap(properties); try { // Create child context and override root context BeanContext = bootstrapContext.CreateService(delegate(IBeanContextFactory bcf) { bcf.RegisterAnonymousBean <MainPageModule>(); bcf.RegisterAnonymousBean(typeof(HelloWorldModule)); AssemblyHelper.HandleTypesFromCurrentDomainWithAnnotation <FrameworkModuleAttribute>(delegate(Type bootstrapModuleType) { //if (!typeof(IInitializingBootstrapMockModule).IsAssignableFrom(bootstrapModuleType)) { if (Log.InfoEnabled) { Log.Info("Autoresolving bootstrap module: '" + bootstrapModuleType.FullName + "'"); } bcf.RegisterAnonymousBean(bootstrapModuleType); } }); bcf.RegisterExternalBean("app", this); }, typeof(RESTBootstrapModule)); FlattenHierarchyProxy.Context = BeanContext; BeanContext.GetService <IThreadPool>().Queue(delegate() { double result = BeanContext.GetService <IHelloWorldService>().DoFunnyThings(5, "hallo"); double result2 = BeanContext.GetService <IHelloWorldService>().DoFunnyThings(6, "hallo"); if (Math.Abs(result - result2) != 1) { throw new Exception("Process execution failed with unexpected result value: " + result + "/" + result2); } Log.Info("" + result); //Type enhancedType = BeanContext.GetService<IBytecodeEnhancer>().GetEnhancedType(typeof(TestEntity), EntityEnhancementHint.HOOK); //TestEntity instance = (TestEntity)Activator.CreateInstance(enhancedType); //instance.Id = 1; //IEntityMetaData metaData = BeanContext.GetService<IEntityMetaDataProvider>().GetMetaData(enhancedType); //IObjRelation result3 = ((IValueHolderContainer)instance).GetSelf("Relation"); //Object targetCache = ((IValueHolderContainer)instance).TargetCache; //((IValueHolderContainer)instance).TargetCache = new ChildCache(); //Console.WriteLine("TestT"); }); SynchronizationContext syncContext = BeanContext.GetService <SynchronizationContext>(); syncContext.Post((object state) => { RootVisual = BeanContext.GetService <UIElement>("mainPage"); }, null); } catch (Exception ex) { if (Log.ErrorEnabled) { Log.Error(ex); } throw; } }
public void Dispose() { if (disposed || disposing) { return; } ILogger log; IServiceContext[] childrenCopy = null; writeLock.Lock(); try { if (disposed || disposing) { return; } log = GetService <ILoggerCache>().GetCachedLogger(this, typeof(ServiceContext)); if (log.DebugEnabled) { // Safe the toString-method for debugging purpose. Because this is not possible anymore if the context // has been disposed and all bean-references have been cleared toStringBackup = StringBuilderUtil.Concat(delegate(StringBuilder sb) { PrintContent(sb); }); } else { toStringBackup = "n/a"; } disposing = true; if (children != null && children.Count > 0) { childrenCopy = new IServiceContext[children.Count]; children.CopyTo(childrenCopy, 0); children.Clear(); } } finally { writeLock.Unlock(); } if (childrenCopy != null) { foreach (IServiceContext childContext in childrenCopy) { try { childContext.Dispose(); } catch (Exception e) { if (log.ErrorEnabled) { log.Error(e); } } } } writeLock.Lock(); try { if (parent != null) { parent.ChildContextDisposed(this); parent = null; } if (this.linkContainers != null) { IList <ILinkContainer> linkContainers = this.linkContainers; this.linkContainers = null; for (int a = linkContainers.Count; a-- > 0;) { ILinkContainer listenerContainer = linkContainers[a]; try { listenerContainer.Unlink(); } catch (System.Exception e) { if (failOnError) { throw; } if (log.ErrorEnabled) { log.Error(e); } } } } if (this.disposableObjects != null) { IList <Object> disposableObjects = this.disposableObjects; this.disposableObjects = null; for (int a = disposableObjects.Count; a-- > 0;) { Object disposableObject = disposableObjects[a]; if (disposableObject is WeakReference) { disposableObject = ((WeakReference)disposableObject).Target; } if (disposableObject is IDisposableBean) { try { ((IDisposableBean)disposableObject).Destroy(); } catch (System.Exception e) { if (failOnError) { throw; } if (log.ErrorEnabled) { log.Error(e); } } } else if (disposableObject is IDisposable) { try { ((IDisposable)disposableObject).Dispose(); } catch (System.Exception e) { if (failOnError) { throw; } if (log.ErrorEnabled) { log.Error(e); } } } else if (disposableObject is IBackgroundWorkerParamDelegate <IServiceContext> ) { try { ((IBackgroundWorkerParamDelegate <IServiceContext>)disposableObject).Invoke(this); } catch (System.Exception e) { if (failOnError) { throw; } if (log.ErrorEnabled) { log.Error(e); } } } } } if (nameToServiceDict != null) { nameToServiceDict.Clear(); } typeToServiceDict.Clear(); if (postProcessors != null) { postProcessors.Clear(); } if (preProcessors != null) { preProcessors.Clear(); } beanContextFactory.Dispose(); } finally { writeLock.Unlock(); beanContextFactory = null; linkContainers = null; nameToServiceDict = null; postProcessors = null; preProcessors = null; parent = null; disposed = true; running = false; } }
public void SetBeanContextFactory(BeanContextFactory beanContextFactory) { CheckNotDisposed(); this.beanContextFactory = beanContextFactory; }