/// <summary> /// Loads the module. /// </summary> /// <param name="assemblyName">Name of the assembly.</param> /// <param name="moduleWorkItem">The module work item.</param> /// <returns>The loaded module assembly.</returns> private Assembly LoadModule(string assemblyName, WorkItem moduleWorkItem) { //// check the assemly in the loaded modules if (!CheckModuleLoaded(assemblyName, moduleWorkItem)) { IModuleInfo[] objModuleInfo = new IModuleInfo[1]; ModuleInfo moduleInfo = new ModuleInfo(assemblyName); objModuleInfo[0] = moduleInfo; ////load the module and add it to moduleWorkItem using moduleLoaderService moduleWorkItem.Services.Get <IModuleLoaderService>().Load(moduleWorkItem, objModuleInfo); } ////enumerate the loaded modules in the application and get the assembly IList <LoadedModuleInfo> listLoadedModules; listLoadedModules = moduleWorkItem.Services.Get <IModuleLoaderService>().LoadedModules; foreach (LoadedModuleInfo loadedModule in listLoadedModules) { if (loadedModule.Assembly.ManifestModule.Name.Equals(assemblyName)) { return(loadedModule.Assembly); } } return(null); }
public void AddModule(IModuleInfo moduleInfo) { if (moduleInfo == null) { throw new ArgumentNullException("moduleInfo"); } // check for completeness of the provided thing if (moduleInfo.Manifest == null || moduleInfo.ModuleData == null) { throw new ArgumentException("Module Info incomplete", "moduleInfo"); } // check for duplications IEnumerable <IModuleInfo> avaliableModules = _storageProvider.GetAvaliableModules(); if (avaliableModules.Any(module => module.Manifest.ModuleName.Equals(moduleInfo.Manifest.ModuleName) && avaliableModules.Any(info => info.Manifest.ModuleVersion.Equals(moduleInfo.Manifest.ModuleVersion)))) { throw new ArgumentException("Duplicate module", "moduleInfo"); } // save into storage _storageProvider.SaveModule(moduleInfo); }
// See CompilePartInfo public static AvailablePart.ModuleInfo GetModuleInfo(PartModule pm) { AvailablePart.ModuleInfo moduleInfo = new AvailablePart.ModuleInfo(); if (pm is IModuleInfo) { IModuleInfo iModuleInfo = pm as IModuleInfo; moduleInfo.moduleName = iModuleInfo.GetModuleTitle(); moduleInfo.info = iModuleInfo.GetInfo().Trim(); moduleInfo.primaryInfo = iModuleInfo.GetPrimaryField(); } else { moduleInfo.moduleName = (pm.GUIName ?? KSPUtil.PrintModuleName(pm.moduleName)); moduleInfo.info = pm.GetInfo().Trim(); } if (pm.showUpgradesInModuleInfo && pm.HasUpgrades()) { moduleInfo.info += "\n" + pm.PrintUpgrades(); } moduleInfo.moduleDisplayName = pm.GetModuleDisplayName(); if (moduleInfo.moduleDisplayName == string.Empty) { moduleInfo.moduleDisplayName = moduleInfo.moduleName; } return(moduleInfo); }
public ActionResult Details(string itemId) { if (string.IsNullOrEmpty(itemId)) { ViewData["Message"] = "No key provided"; return(View("Error")); } IModuleInfo selectedModel = _repositoryModel.ModuleInfosList .Where(x => x.Id.Equals(itemId)) .Select(x => x) .DefaultIfEmpty(null) .SingleOrDefault(); // check validity of the moduleInfo if (selectedModel == null) { return(View("FileNotFound")); } if (selectedModel.Manifest == null || selectedModel.ModuleData == null) { return(View("FileNotFound")); } // if everything's ok go to details return(View("Details", selectedModel)); }
public void CancelRealtimeFeed( IModuleInfo clientInfo, Guid subscriptionId, AsyncQueueCallback <QuotedAssetSet> callback) { _mds.CancelRealtimeFeed(clientInfo, subscriptionId, callback); }
/// <summary> /// Initializes a new instance of the <see cref="ModuleDownloadProgressChangedEventArgs"/> class. /// </summary> /// <param name="moduleInfo">The module info.</param> /// <param name="bytesReceived">The bytes received.</param> /// <param name="totalBytesToReceive">The total bytes to receive.</param> public ModuleDownloadProgressChangedEventArgs(IModuleInfo moduleInfo, long bytesReceived, long totalBytesToReceive) : base(CalculateProgressPercentage(bytesReceived, totalBytesToReceive), null) { ModuleInfo = moduleInfo ?? throw new ArgumentNullException(nameof(moduleInfo)); BytesReceived = bytesReceived; TotalBytesToReceive = totalBytesToReceive; }
public ActionResult Remove(string itemId) { if (string.IsNullOrEmpty(itemId)) { ViewData["Message"] = "No key provided"; return(View("Error")); } IModuleInfo item = _repositoryModel.ModuleInfosList .Where(x => x.Id.Equals(itemId)) .Select(x => x) .DefaultIfEmpty(null) .SingleOrDefault(); if (item == null) { ViewData["Message"] = "Key could not be found in database"; return(View("Error")); } try { _repositoryModel.RemoveModule(item); } catch (Exception e) { ViewData["Message"] = e.Message; return(View("Error")); } return(RedirectToAction("Index")); }
/// <summary> /// Handles any exception occurred in the module Initialization process, /// This method can be overridden to provide a different behavior. /// </summary> /// <param name="moduleInfo">The module metadata where the error happened.</param> /// <param name="assemblyName">The assembly name.</param> /// <param name="exception">The exception thrown that is the cause of the current error.</param> /// <exception cref="ModuleInitializeException"></exception> public virtual void HandleModuleInitializationError(IModuleInfo moduleInfo, string assemblyName, Exception exception) { if (moduleInfo == null) { throw new ArgumentNullException(nameof(moduleInfo)); } if (exception == null) { throw new ArgumentNullException(nameof(exception)); } Exception moduleException; if (exception is ModuleInitializeException) { moduleException = exception; } else { if (!string.IsNullOrEmpty(assemblyName)) { moduleException = new ModuleInitializeException(moduleInfo.ModuleName, assemblyName, exception.Message, exception); } else { moduleException = new ModuleInitializeException(moduleInfo.ModuleName, exception.Message, exception); } } throw moduleException; }
public void Initialize(IModuleInfo moduleInfo) { if (moduleInfo == null) { throw new ArgumentNullException(nameof(moduleInfo)); } IModule moduleInstance = null; try { moduleInstance = this.CreateModule(moduleInfo); if (moduleInstance != null) { moduleInstance.RegisterTypes(_containerExtension); moduleInstance.OnInitialized(_containerExtension); } } catch (Exception ex) { this.HandleModuleInitializationError( moduleInfo, moduleInstance?.GetType().Assembly.FullName, ex); } }
public ActionResult UploadPackage(HttpPostedFileBase file) { if (file == null) { return(RedirectToAction("Index", "Home")); } // save file into memory stream using (var memoryStream = new MemoryStream()) { file.InputStream.Position = 0; while (file.InputStream.Position < file.InputStream.Length) { var dataSinge = (byte)file.InputStream.ReadByte(); memoryStream.WriteByte(dataSinge); } // get the module info from stream try { IModuleInfo moduleInfo = _zipPackager.UnPack(memoryStream.ToArray()); _repositoryModel.AddModule(moduleInfo); } catch (Exception e) { ViewData["Message"] = e.Message; return(View("Error")); } } return(RedirectToAction("Index", "Home")); }
private static IModuleInfo GetMatch(List <IModuleInfo> matches, string relativeRequestUrl) { bool isRoot = false; if (VirtualPathUtility.GetDirectory(relativeRequestUrl).Equals("~/", StringComparison.InvariantCultureIgnoreCase)) { isRoot = true; } IModuleInfo longestMatch = matches[0]; foreach (IModuleInfo match in matches) { if (isRoot && match.VirtualPath.Equals("~/", StringComparison.InvariantCultureIgnoreCase)) { return(match); } if (match.VirtualPath.Length > longestMatch.VirtualPath.Length) { longestMatch = match; } } return(longestMatch); }
private void CmdReceived(IModuleInfo obj) { if (obj.ModuleType == typeof(EncodeModule).AssemblyQualifiedName) { _eventAggregator.GetEvent <MessageSentEvent>().Publish(new EventWithPater(obj, Message)); } }
public V221OutputQuotedAssetSet GetPricingStructureV221(V221Header header, V221ProviderId provider, Guid requestId, string requestParams, string structureProperties) { IModuleInfo connection = null; _connectionIndex.Locked(connections => { if (!connections.TryGetValue(header.SessionId, out connection)) { throw new ApplicationException("Ignoring request from unknown client!"); } }); //var errors = new List<V221ErrorDetail>(); string step = "GetPricingStructureV221: unknown"; try { step = "GetPricingStructureV221: calling GetPricingStructure"; // run each provider request MDSProviderId defaultProvider = V221Helpers.ToProviderId(provider); MDSResult <QuotedAssetSet> result = _providers[(int)defaultProvider].GetPricingStructure( defaultProvider, connection, requestId, true, new NamedValueSet(requestParams), new NamedValueSet(structureProperties)); step = "GetPricingStructureV221: compressing"; return(new V221OutputQuotedAssetSet( CompressionHelper.CompressToBuffer(XmlSerializerHelper.SerializeToString(result)), null)); } catch (Exception excp) { Logger.LogError("Exception: step='{0}': {1}", step, excp); return(new V221OutputQuotedAssetSet(null, new V221ErrorDetail(excp))); } }
/// <summary> /// Handles any exception occurred in the module Initialization process, /// logs the error using the <see cref="ILoggerFacade"/> and throws a <see cref="ModuleInitializeException"/>. /// This method can be overridden to provide a different behavior. /// </summary> /// <param name="moduleInfo">The module metadata where the error happenened.</param> /// <param name="assemblyName">The assembly name.</param> /// <param name="exception">The exception thrown that is the cause of the current error.</param> /// <exception cref="ModuleInitializeException"></exception> public virtual void HandleModuleInitializationError(IModuleInfo moduleInfo, string assemblyName, Exception exception) { if (moduleInfo == null) { throw new ArgumentNullException(nameof(moduleInfo)); } if (exception == null) { throw new ArgumentNullException(nameof(exception)); } Exception moduleException; if (exception is ModuleInitializeException) { moduleException = exception; } else { if (!string.IsNullOrEmpty(assemblyName)) { moduleException = new ModuleInitializeException(moduleInfo.ModuleName, assemblyName, exception.Message, exception); } else { moduleException = new ModuleInitializeException(moduleInfo.ModuleName, exception.Message, exception); } } this._loggerFacade.Log(moduleException.ToString(), Category.Exception, Priority.High); throw moduleException; }
// constructors /// <summary> /// /// </summary> /// <param name="moduleInfo"></param> /// <param name="cryptoManager"></param> /// <param name="itemKind"></param> /// <param name="transient"></param> /// <param name="appScope"></param> /// <param name="name"></param> /// <param name="props"></param> /// <param name="data"></param> /// <param name="dataType"></param> /// <param name="serialFormat"></param> /// <param name="lifetime"></param> public ServerItem( IModuleInfo moduleInfo, ICryptoManager cryptoManager, ItemKind itemKind, bool transient, string appScope, string name, NamedValueSet props, object data, Type dataType, SerialFormat serialFormat, TimeSpan lifetime) : base(itemKind, transient, name, appScope) { _moduleInfo = moduleInfo ?? throw new ArgumentNullException(nameof(moduleInfo)); _cryptoManager = cryptoManager ?? throw new ArgumentNullException(nameof(cryptoManager)); if (dataType == null) { throw new ArgumentNullException(nameof(dataType)); } SysProps.Set(SysPropName.SAlg, (int)serialFormat); AppProps.Add(props); _data = data; _dataTypeType = dataType; DataTypeName = dataType.FullName; _lifetime = lifetime; }
public void Initialize(IModuleInfo moduleInfo) { if (moduleInfo == null) { throw new ArgumentNullException(nameof(moduleInfo)); } IModule moduleInstance = null; try { moduleInstance = this.CreateModule(moduleInfo); if (moduleInstance != null) { var mutableContainer = _containerExtension.GetMutableContainer(); mutableContainer.RegisterTypes(builder => { var registry = new AutofacContainerRegistry(builder, mutableContainer); moduleInstance.RegisterTypes(registry); registry.FinalizeRegistry(); }); moduleInstance.OnInitialized(_containerExtension); } } catch (Exception ex) { this.HandleModuleInitializationError( moduleInfo, moduleInstance != null ? moduleInstance.GetType().Assembly.FullName : null, ex); } }
public void SaveModule(IModuleInfo moduleInfo) { // get the max var maxes = _db.Modules.Select(x => x.Id).ToList(); decimal max; if (maxes.Count == 0) { max = 0; } else { max = maxes.Max(x => x); max++; } var module = new Module() { Id = max, Manifest = XmlSerializerHelper.Serialize(moduleInfo.Manifest), ModuleData = moduleInfo.ModuleData, }; _db.Modules.InsertOnSubmit(module); _db.SubmitChanges(); }
public void Add(IModuleInfo module) { if (module != null) { m_modules.Add(module); } }
public void SaveModule(IModuleInfo moduleInfo) { IModuleInfo existingItem = _modulesInfos.Where(x => x.Id == moduleInfo.Id).FirstOrDefault(); if (existingItem != null) _modulesInfos.Remove(existingItem); _modulesInfos.Add(moduleInfo); }
public ViewInfo(string viewName, Type viewType, IModuleInfo module, bool isSingleton, bool needAccess, SingletonTypes type) { m_viewType = viewType; m_viewName = viewName; m_module = module; m_isSingleton = isSingleton; m_needAccess = needAccess; m_singletonType = type; }
protected override IModule CreateModule(IModuleInfo moduleInfo) { if (ModuleIsInUserRole(moduleInfo)) { return(base.CreateModule(moduleInfo)); } return(null); }
IEnumerable <IModuleInfo> IModuleCatalog.GetDependentModules(IModuleInfo moduleInfo) { if (GetDependentModules == null) { return(new List <IModuleInfo>()); } return(GetDependentModules(moduleInfo)); }
/// <summary> /// Evaluates the <see cref="IModuleInfo.Ref"/> property to see if the current typeloader will be able to retrieve the <paramref name="moduleInfo"/>. /// Returns true if the <see cref="IModuleInfo.Ref"/> property starts with "file://", because this indicates that the file /// is a local file. /// </summary> /// <param name="moduleInfo">Module that should have it's type loaded.</param> /// <returns> /// <see langword="true"/> if the current typeloader is able to retrieve the module, otherwise <see langword="false"/>. /// </returns> /// <exception cref="ArgumentNullException">An <see cref="ArgumentNullException"/> is thrown if <paramref name="moduleInfo"/> is null.</exception> public bool CanLoadModuleType(IModuleInfo moduleInfo) { if (moduleInfo == null) { throw new ArgumentNullException(nameof(moduleInfo)); } return(moduleInfo.Ref != null && moduleInfo.Ref.StartsWith(RefFilePrefix, StringComparison.Ordinal)); }
public static bool HasRole(this IModuleInfo moduleInfo, string role) { if (moduleInfo.HasAttribute(out ModuleRoleAttribute moduleRoleAttribute)) { return(moduleRoleAttribute.SupportsRole(role)); } return(false); }
public static bool HasAttribute <TAttribute>(this IModuleInfo moduleInfo, out TAttribute attribute) where TAttribute : Attribute { var moduleType = Type.GetType(moduleInfo.ModuleType); attribute = moduleType.GetCustomAttributes <TAttribute>().FirstOrDefault(); return(attribute != null); }
void InitializeModule(IModuleInfo moduleInfo) { if (moduleInfo.State == ModuleState.Initializing) { _moduleInitializer.Initialize(moduleInfo); moduleInfo.State = ModuleState.Initialized; RaiseLoadModuleCompleted(moduleInfo, null); } }
public void PublishMarketData( IModuleInfo clientInfo, Guid requestId, NamedValueSet requestParams, TimeSpan dataLifetime, QuotedAssetSet marketDataSet) { OnPublishMarketData(requestId, requestParams, dataLifetime, marketDataSet); }
/// <summary> /// Uses the container to resolve a new <see cref="IModule"/> by specifying its <see cref="Type"/>. /// </summary> /// <param name="moduleInfo">The module to create.</param> /// <returns>A new instance of the module specified by <paramref name="moduleInfo"/>.</returns> protected virtual IModule CreateModule(IModuleInfo moduleInfo) { if (moduleInfo == null) { throw new ArgumentNullException(nameof(moduleInfo)); } return(this.CreateModule(moduleInfo.ModuleType)); }
public void RemoveModule(IModuleInfo moduleInfo) { IModuleInfo existingItem = _modulesInfos.Where(x => x.Id == moduleInfo.Id).FirstOrDefault(); if (existingItem != null) _modulesInfos.Remove(existingItem); else throw new InvalidOperationException("Specified item does not exist!"); }
public void Initialize(IModuleInfo moduleInfo) { var module = CreateModule(Type.GetType(moduleInfo.ModuleType, true)); if (module != null) { module.RegisterTypes(_container); module.OnInitialized(_container); } }
protected virtual MDSResult <QuotedAssetSet> OnRequestPricingStructure( IModuleInfo clientInfo, Guid requestId, MDSRequestType requestType, NamedValueSet requestParams, DateTimeOffset subsExpires, NamedValueSet structureParams) { throw new NotSupportedException("This provider (" + ProviderId.ToString() + ") does not support the OnRequestPricingStructure method!"); }
/// <summary> /// Initializes a new instance of the <see cref="LoadModuleCompletedEventArgs"/> class. /// </summary> /// <param name="moduleInfo">The module info.</param> /// <param name="error">Any error that occurred during the call.</param> public LoadModuleCompletedEventArgs(IModuleInfo moduleInfo, Exception error) { if (moduleInfo == null) { throw new ArgumentNullException(nameof(moduleInfo)); } this.ModuleInfo = moduleInfo; this.Error = error; }
public void RemoveModule(IModuleInfo moduleInfo) { var module = _db.Modules .Where( x => x.Id.ToString().Equals(moduleInfo.Id)) .Select(x => x) .Single(); _db.Modules.DeleteOnSubmit(module); _db.SubmitChanges(); }
public void SaveModule(IModuleInfo moduleInfo) { // make the new id for newly saved thing var info = new ModuleInfo() { Id = GetNewId(), Manifest = moduleInfo.Manifest, ModuleData = moduleInfo.ModuleData, }; _moduleInfos.Add(info); }
internal static VModuleInfo C2V(IModuleInfo contract) { if (!System.Runtime.Remoting.RemotingServices.IsObjectOutOfAppDomain(contract) && (contract.GetType().Equals(typeof(ModuleInfoV2C)))) { return ((ModuleInfoV2C)(contract)).GetSourceView(); } else { return new ModuleInfoC2V(contract); } }
private GuidancePackageModuleInfo Translate(IModuleInfo moduleInfo) { DependantModuleInfo dependantModuleInfo = moduleInfo as DependantModuleInfo; GuidancePackageModuleInfo wcsfModuleInfo = new GuidancePackageModuleInfo(moduleInfo.Name, moduleInfo.AssemblyName, moduleInfo.VirtualPath); if (dependantModuleInfo != null) { wcsfModuleInfo.Dependencies = dependantModuleInfo.Dependencies; } return wcsfModuleInfo; }
public void RemoveModule(IModuleInfo moduleInfo) { if (moduleInfo == null) throw new ArgumentNullException("moduleInfo"); // check for existence IEnumerable<IModuleInfo> modules = _storageProvider.GetAvaliableModules(); if (!modules.Any(module => module.Id.Equals(moduleInfo.Id))) throw new ArgumentException("No such module info in collection", "moduleInfo"); // remove from storage _storageProvider.RemoveModule(moduleInfo); }
public GuidancePackageModuleInfo[] Translate(IModuleInfo[] dependantModules) { if (dependantModules == null) { return null; } GuidancePackageModuleInfo[] moduleInfo = new GuidancePackageModuleInfo[dependantModules.Length]; for (int i = 0; i < dependantModules.Length; i++) { moduleInfo[i] = Translate(dependantModules[i]); } return moduleInfo; }
public AssemblyNode CreateAssemblyNode(IModuleInfo module, CciMethodMatcher methodMatcher) { var matcher = methodMatcher.Join(new SolutionTypesManager.ProperlyNamedMatcher()); var assemblyNode = new AssemblyNode(module.Name); assemblyNode.AssemblyPath = module.Module.Location.ToFilePathAbs(); System.Action<CheckedNode, ICollection<INamedTypeDefinition>> typeNodeCreator = (parent, leafTypes) => { foreach (INamedTypeDefinition typeDefinition in leafTypes) { if (matcher.Matches(typeDefinition)) { var type = new TypeNode(parent, typeDefinition.Name.Value); foreach (var method in typeDefinition.Methods) { if (matcher.Matches(method)) { type.Children.Add(new MethodNode(type, method.Name.Value, method, false)); return; } } parent.Children.Add(type); } } }; Func<INamedTypeDefinition, string> namespaceExtractor = typeDef => TypeHelper.GetDefiningNamespace(typeDef).Name.Value; NamespaceGrouper<INamespaceTypeDefinition, CheckedNode>. GroupTypes(assemblyNode, namespaceExtractor, (parent, name) => new TypeNamespaceNode(parent, name), typeNodeCreator, module.Module.GetAllTypes().ToList()); //remove empty amespaces. //TODO to refactor... List<TypeNamespaceNode> checkedNodes = assemblyNode.Children.OfType<TypeNamespaceNode>().ToList(); foreach (TypeNamespaceNode node in checkedNodes) { RemoveFromParentIfEmpty(node); } return assemblyNode; }
public void AddModule(IModuleInfo moduleInfo) { if (moduleInfo == null) throw new ArgumentNullException("moduleInfo"); // check for completeness of the provided thing if ( moduleInfo.Manifest == null || moduleInfo.ModuleData == null) throw new ArgumentException("Module Info incomplete", "moduleInfo"); // check for duplications IEnumerable<IModuleInfo> avaliableModules = _storageProvider.GetAvaliableModules(); if (avaliableModules.Any(module => module.Manifest.ModuleName.Equals(moduleInfo.Manifest.ModuleName) && avaliableModules.Any(info => info.Manifest.ModuleVersion.Equals(moduleInfo.Manifest.ModuleVersion)))) throw new ArgumentException("Duplicate module", "moduleInfo"); // save into storage _storageProvider.SaveModule(moduleInfo); }
public void SaveModule(IModuleInfo moduleInfo) { // get the max var maxes = _db.Modules.Select(x => x.Id).ToList(); decimal max; if (maxes.Count == 0) max = 0; else { max = maxes.Max(x => x); max++; } var module = new Module() { Id = max, Manifest = XmlSerializerHelper.Serialize(moduleInfo.Manifest), ModuleData = moduleInfo.ModuleData, }; _db.Modules.InsertOnSubmit(module); _db.SubmitChanges(); }
private void LoadAssemblies(IModuleInfo[] modules) { foreach (IModuleInfo module in modules) { GuardLegalAssemblyFile(module); Assembly assembly = LoadAssembly(module.AssemblyFile); if (!loadedModules.ContainsKey(assembly)) loadedModules.Add(assembly, new ModuleMetadata(assembly, traceSource, module)); } }
private void InnerLoad(WorkItem workItem, IModuleInfo[] modules) { if (modules.Length == 0) return; IModuleInfo[] allowedModules = FilterModulesBasedOnRole(modules); LoadAssemblies(allowedModules); List<ModuleMetadata> loadOrder = GetLoadOrder(); foreach (ModuleMetadata module in loadOrder) module.LoadServices(workItem); foreach (ModuleMetadata module in loadOrder) module.InitializeWorkItemExtensions(workItem); foreach (ModuleMetadata module in loadOrder) module.InitializeModuleClasses(workItem); foreach (ModuleMetadata module in loadOrder) module.NotifyOfLoadedModule(OnModuleLoaded); }
private void GuardLegalAssemblyFile(IModuleInfo modInfo) { Guard.ArgumentNotNull(modInfo, "modInfo"); Guard.ArgumentNotNull(modInfo.AssemblyFile, "modInfo.AssemblyFile"); string assemblyFilePath = GetModulePath(modInfo.AssemblyFile); if (!File.Exists(assemblyFilePath)) throw new ModuleLoadException( string.Format(CultureInfo.CurrentCulture, Properties.Resources.ModuleNotFound, assemblyFilePath)); }
private IModuleInfo[] FilterModulesBasedOnRole(IModuleInfo[] modules) { List<IModuleInfo> allowedModules = new List<IModuleInfo>(); foreach (IModuleInfo module in modules) { if (module.AllowedRoles.Count == 0) allowedModules.Add(module); else { foreach (string role in module.AllowedRoles) { if (Thread.CurrentPrincipal.IsInRole(role)) { allowedModules.Add(module); break; } } } } return allowedModules.ToArray(); }
private IModuleInfo FindRootVirtualPathModuleInfo(IModuleInfo[] moduleInfos) { foreach (IModuleInfo moduleInfo in moduleInfos) { if (moduleInfo.VirtualPath != null && RemoveTrailingWack(moduleInfo.VirtualPath).Equals("~", StringComparison.InvariantCultureIgnoreCase)) { return moduleInfo; } } return null; }
void Module_Loaded(IModuleInfo module) { _loaded_modules.Add(module.Name); _need_to_refresh_parts = true; }
public void WriteToStream(IModuleInfo moduleInfo, FileStream stream, string filePath) { var module = (ModuleInfo)moduleInfo; if (module.PdbReader == null) { PeWriter.WritePeToStream(module.Module, _host, stream); } else { using (var pdbWriter = new PdbWriter(Path.ChangeExtension(filePath, "pdb"), module.PdbReader)) { PeWriter.WritePeToStream(module.Module, _host, stream, module.PdbReader, module.PdbReader, pdbWriter); } } }
public void Initialize(IPlatform platform, ILogger logger, IModuleInfo moduleInfo, int secret) { _view.Initialize(PlatformAdapter.C2V(platform), LoggerAdapter.C2V(logger), ModuleInfoAdapter.C2V(moduleInfo), secret); }
private IModuleInfo FindModuleInfoInSubWebProject(IModuleInfo[] moduleInfos, Project webProject) { string projectAbosultePath = RemoveTrailingWack(webProject.Properties.Item("FullPath").Value.ToString()); while (projectAbosultePath.Length > 0) { foreach (IModuleInfo moduleInfo in moduleInfos) { if (moduleInfo.VirtualPath != null) { string moduleInfoAbsolutePath = BuildModuleAbsoluteFolderPath(webProject, moduleInfo); if (String.Equals(projectAbosultePath, moduleInfoAbsolutePath, StringComparison.InvariantCultureIgnoreCase)) { return moduleInfo; } } } projectAbosultePath = Path.GetDirectoryName(projectAbosultePath); } return null; }
private IProjectItemModel SelectWebFolder(IList<IProjectItemModel> moduleFolders, IProjectModel moduleProject, IProjectModel webProject, IModuleInfo[] moduleInfoCollection) { if (moduleInfoCollection != null) { foreach (IModuleInfo moduleInfo in moduleInfoCollection) { if (String.Compare(moduleInfo.AssemblyName, moduleProject.AssemblyName, StringComparison.InvariantCultureIgnoreCase) == 0) { foreach (IProjectItemModel moduleFolder in moduleFolders) { if (moduleInfo.VirtualPath != null) { string moduleFolderPath = Path.Combine(webProject.ProjectPath, ConvertToPhysicalPath(moduleInfo.VirtualPath)); if (String.Compare(moduleFolder.ItemPath, moduleFolderPath, StringComparison.InvariantCultureIgnoreCase) == 0) { return moduleFolder; } } } } } } return null; }
private List<IProjectModel> FilterProjectsWithVirtualPath(List<IProjectModel> moduleProjects, IModuleInfo[] moduleInfos) { List<IProjectModel> filtered = new List<IProjectModel>(); foreach (IProjectModel project in moduleProjects) { IModuleInfo projectModuleInfo = FindModuleInfo(project.AssemblyName, moduleInfos); if (projectModuleInfo != null) { if (!string.IsNullOrEmpty(projectModuleInfo.VirtualPath)) { filtered.Add(project); } } } return filtered; }
public CatalogueModuleLayout(IModuleInfo module) { this.InitializeComponent(); this.module = module; this.moduleName.Text = module.Name; }
public ModuleMetadata(Assembly assembly, TraceSource traceSource, IModuleInfo moduleInfo) { this.assembly = assembly; this.traceSource = traceSource; if (moduleInfo is IDependentModuleInfo) { name = ((IDependentModuleInfo)moduleInfo).Name; dependencies.AddRange(((IDependentModuleInfo)moduleInfo).Dependencies); } else { foreach (ModuleAttribute attr in assembly.GetCustomAttributes(typeof(ModuleAttribute), true)) name = attr.Name; foreach (ModuleDependencyAttribute attr in assembly.GetCustomAttributes(typeof(ModuleDependencyAttribute), true)) dependencies.Add(attr.Name); } foreach (Type type in assembly.GetExportedTypes()) { foreach (ServiceAttribute attr in type.GetCustomAttributes(typeof(ServiceAttribute), true)) services.Add(new ServiceMetadata(type, attr.RegisterAs ?? type, attr.AddOnDemand)); foreach (WorkItemExtensionAttribute attr in type.GetCustomAttributes(typeof(WorkItemExtensionAttribute), true)) workItemExtensions.Add(new KeyValuePair<Type, Type>(attr.WorkItemType, type)); foreach (RootWorkItemExtensionAttribute attr in type.GetCustomAttributes(typeof(RootWorkItemExtensionAttribute), true)) workItemRootExtensions.Add(type); if (!type.IsAbstract && typeof(IModule).IsAssignableFrom(type)) moduleTypes.Add(type); } }
public void LoadModule(IModuleInfo module) { //_moduleLoaderService.ModuleLoaded += new EventHandler<DataEventArgs<LoadedModuleInfo>>(OnModuleLoaded); _moduleLoaderService.Load(_workItem, module); }
public MemoryStream WriteToStream(IModuleInfo moduleInfo) { var module = (ModuleInfo)moduleInfo; _log.Info("CommonCompilerInfra.WriteToFile:" + module.Name); MemoryStream stream = new MemoryStream(); if (module.PdbReader == null) { PeWriter.WritePeToStream(module.Module, _host, stream); } else { throw new NotImplementedException(); // using (var pdbWriter = new PdbWriter(Path.ChangeExtension(filePath, "pdb"), module.PdbReader)) // { // PeWriter.WritePeToStream(module.Module, _host, stream, module.SourceLocationProvider, // module.LocalScopeProvider, pdbWriter); // } } stream.Position = 0; return stream; }
public void RemoveModule(IModuleInfo moduleInfo) { _moduleInfos.Remove(moduleInfo); }
private IModuleInfo FindModuleInfo(string assemblyName, IModuleInfo[] modules) { List<IModuleInfo> moduleList = new List<IModuleInfo>(modules); return moduleList.Find(delegate(IModuleInfo match) { return match.AssemblyName == assemblyName; }); }
public ModuleInfoC2V(IModuleInfo contract) { _contract = contract; _handle = new ContractHandle(contract); }
private static void LoadServices(CompositionContainer container, IModuleInfo moduleInfo) { IServiceLoaderService serviceLoader = container.Services.Get<IServiceLoaderService>(); if (serviceLoader == null) return; DependantModuleInfo dependantModuleInfo = moduleInfo as DependantModuleInfo; if (dependantModuleInfo != null && dependantModuleInfo.Services != null) { serviceLoader.Load(container, dependantModuleInfo.Services); } }