public ComponentMetadata DisableComponent(int componentId) { ComponentMetadata rc = null; _logger.Log(string.Format("Attempting to disable component with id \"{0}\".", componentId)); var type = GetComponentType(componentId); if (type.Key != null) { rc = type.Value; if (type.Value.UserActions.HasFlag(ComponentUserActions.Disable)) { if (!type.Value.IsDisabled) { StopRunnable(GetIRunnable(type.Key)); type.Value.IsDisabled = true; _logger.Log(string.Format("Component with id \"{0}\" has been disabled.", type.Value.FriendlyName)); } else { _logger.Log(string.Format("Component with id \"{0}\" has already been disabled.", type.Value.FriendlyName), LogMessageSeverity.Warning); } } else { _logger.Log(string.Format("Cannot disable component \"{0}\".", type.Value.FriendlyName), LogMessageSeverity.Warning); } } return(rc); }
/// <summary> /// Validates if all components exist in the library, and their mapping format. /// </summary> /// <param name="vertices">The vertices.</param> /// <returns>true if all components are in the library, false otherwise</returns> private static bool ValidComponents(List <ExperimentNode> vertices) { bool noErrors = true; //validate if all components are in the library foreach (ExperimentNode node in vertices) { ComponentMetadata componentMetadata = node.Data.Metadata as ComponentMetadata; if (componentMetadata != null) { if (componentMetadata.ComponentMetadataDefinition == null) { noErrors = false; string errorMessage = String.Format(System.Globalization.CultureInfo.CurrentCulture, "Component library does not contain any Component of the given ID {0}", componentMetadata.ComponentMetadataDefinitionID); NLog.LogManager.GetCurrentClassLogger().Error(errorMessage); node.SetError(errorMessage); } else { //if component exist check also output mapping formats string errorMessage; if (CheckOutputMappingFormat(componentMetadata, out errorMessage) == false) { noErrors = false; NLog.LogManager.GetCurrentClassLogger().Error(errorMessage); node.SetError(errorMessage); } } } } return(noErrors); }
public RunnableNode CreateNode(string id, Metadata metadata, System.Threading.ManualResetEvent terminateExperimentExecutionResetEvent) { StartNodeMetadata startNodeMetadata = metadata as StartNodeMetadata; EndNodeMetadata endNodeMetadata = metadata as EndNodeMetadata; ComponentMetadata componentMetadata = metadata as ComponentMetadata; if (startNodeMetadata != null) { return(new RunnableStartNode(id)); } else if (endNodeMetadata != null) { return(new RunnableEndNode(id, endNodeMetadata.WaitsForAllPredecessors)); } else if (componentMetadata != null) { //mock failure if (componentMetadata.Label.Equals("Broken Component")) { throw new ArgumentException("Failed"); } //otherwise create a mock node and keep reference MockNode mockNode = new MockNode(id); CreatedNodes.Add(mockNode); return(mockNode); } else { throw new ArgumentException("Could not identify node type."); } }
public ComponentMetadata RestartComponent(int componentId) { ComponentMetadata rc = null; _logger.Log(string.Format("Attempting to restart component with id \"{0}\".", componentId)); var type = GetComponentType(componentId); if (type.Key != null) { rc = type.Value; if (type.Value.UserActions.HasFlag(ComponentUserActions.Restart)) { StopRunnable(GetIRunnable(type.Key)); StartRunnable(GetIRunnable(type.Key)); } else { _logger.Log(string.Format("Cannot restart component \"{0}\". This component is not restartable", type.Value.FriendlyName), LogMessageSeverity.Warning); } } return(rc); }
private ComponentMetadata GetMetadata(Type type) { ComponentMetadata info = null; if (type != null) { IEnumerable <KeyValuePair <Type, Type> > query; if (type.IsInterface) { query = _container.GetRegisteredTypes().Where(k => k.Key == type); } else { query = _container.GetRegisteredTypes().Where(k => k.Value == type); } if (query.Any()) { info = GetMetadata(query.First()); } } return(info); }
/// <summary> /// Creates the Runnable node with a specific id based on the given metadata. /// Uses Composite Component Metadata config values to override Components config values in subgraph. /// </summary> /// <param name="id">The id of the node.</param> /// <param name="metadata">The component metadata.</param> /// <param name="loggerNameRoot">The logger name root - needed so that the logs are specific per experiment and experiment window.</param> /// <param name="library">The library of components.</param> /// <param name="componentsAppDomain">The components app domain is the app domain which components assemblies are going to be loaded into.</param> /// <param name="terminateExperimentExecutionResetEvent">The event that allows signalling termination of the experiment; /// Needed for the composite components sublevel experiments, so that they hold the referance to the same termination event as top level experiment</param> /// <returns> /// Created node /// </returns> public override RunnableNode CreateNode(String id, Metadata metadata, LoggerNameRoot loggerNameRoot, ComponentsLibrary library, AppDomain componentsAppDomain, System.Threading.ManualResetEvent terminateExperimentExecutionResetEvent) { RunnableNode retNode; ComponentMetadata originalComponentMetadata = metadata as ComponentMetadata; CompositeComponentMetadata compositeComponentMetadata = metadata as CompositeComponentMetadata; if (originalComponentMetadata != null) { ComponentMetadata overrideComponentMetadata = (ComponentMetadata)originalComponentMetadata.Clone(); OverrideConfigValues(id, overrideComponentMetadata); retNode = base.CreateNode(id, overrideComponentMetadata, loggerNameRoot, library, componentsAppDomain, terminateExperimentExecutionResetEvent); } else if (compositeComponentMetadata != null) { OverrideConfigValues(id, compositeComponentMetadata); retNode = base.CreateCompositeComponentNode(id, compositeComponentMetadata, loggerNameRoot, library, componentsAppDomain, terminateExperimentExecutionResetEvent); } else { retNode = base.CreateNode(id, metadata, loggerNameRoot, library, componentsAppDomain, terminateExperimentExecutionResetEvent); } return(retNode); }
public ComponentDirectiveVisitor(string filePath, IReadOnlyList <TagHelperDescriptor> tagHelpers, string currentNamespace) { _filePath = filePath; // We don't want to consider non-component tag helpers in a component document. _tagHelpers = tagHelpers.Where(t => ComponentMetadata.IsComponentTagHelperKind(t.Kind) && !IsTagHelperFromMangledClass(t)).ToList(); for (var i = 0; i < _tagHelpers.Count; i++) { var tagHelper = _tagHelpers[i]; if (tagHelper.IsComponentFullyQualifiedNameMatch()) { // If the component descriptor matches for a fully qualified name, using directives shouldn't matter. Matches.Add(tagHelper); continue; } var typeName = tagHelper.GetTypeName(); if (tagHelper.IsChildContentTagHelper()) { // If this is a child content tag helper, we want to add it if it's original type is in scope. // E.g, if the type name is `Test.MyComponent.ChildContent`, we want to add it if `Test.MyComponent` is in scope. TrySplitNamespaceAndType(typeName, out typeName, out var _); } if (currentNamespace != null && IsTypeInScope(typeName, currentNamespace)) { // Also, if the type is already in scope of the document's namespace, using isn't necessary. Matches.Add(tagHelper); } } }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="component">The metadata of the component that was found in multiple locations of a component hierarchy.</param> internal InvalidHierarchyStructureException(ComponentMetadata component) : base("A component has been found in multiple locations of the component hierarchy; " + "the 'Component' property contains the metadata of the component that violated the hierarchy constraint.") { Requires.NotNull(component, () => component); Component = component; }
private void UpdateAllUsers(ComponentMetadata data) { if (data != null) { Broadcast((IComponentServiceCallback c) => c.ComponentUpdated(data)); } }
/// <summary> /// Creates the Runnable node with a specific id based on the given metadata. /// </summary> /// <param name="nodeId">The node id.</param> /// <param name="metadata">The component metadata.</param> /// <param name="loggerNameRoot">The logger name root - needed so that the logs are specific per experiment and experiment window.</param> /// <param name="library">The library of components.</param> /// <param name="componentsAppDomain">The components app domain is the app domain which components assemblies are going to be loaded into.</param> /// <param name="terminateExperimentExecutionResetEvent">The event that allows signalling termination of the experiment; /// Needed for the composite components sublevel experiments, so that they hold the referance to the same termination event as top level experiment.</param> /// <returns> /// Created node /// </returns> public virtual RunnableNode CreateNode(String nodeId, Metadata metadata, LoggerNameRoot loggerNameRoot, ComponentsLibrary library, AppDomain componentsAppDomain, System.Threading.ManualResetEvent terminateExperimentExecutionResetEvent) { RunnableNode retNode; ComponentMetadata componentMetadata = metadata as ComponentMetadata; DecisionMetadata decisionMetadata = metadata as DecisionMetadata; StartNodeMetadata startNodeMetadata = metadata as StartNodeMetadata; EndNodeMetadata endNodeMetadata = metadata as EndNodeMetadata; ScopeBaseMetadata scopeMetadata = metadata as ScopeBaseMetadata; LoopScopeMetadata loopMetadata = metadata as LoopScopeMetadata; CompositeComponentMetadata compositeComponentMetadata = metadata as CompositeComponentMetadata; ExitDecisionMetadata exitDecisionMetadata = metadata as ExitDecisionMetadata; if (componentMetadata != null) { TraceLabSDK.ComponentLogger logger = TraceLab.Core.Components.LoggerFactory.CreateLogger(loggerNameRoot, nodeId, componentMetadata); IComponent component = library.LoadComponent(componentMetadata, Workspace, logger, componentsAppDomain); retNode = new RunnableComponentNode(nodeId, componentMetadata.Label, component, logger, library, componentMetadata.WaitsForAllPredecessors); } else if (decisionMetadata != null) { IDecisionModule decisionModule = DecisionModuleFactory.LoadDecisionModule(decisionMetadata, Workspace, componentsAppDomain); retNode = new RunnableDecisionNode(nodeId, decisionMetadata.Label, decisionModule, library, decisionMetadata.WaitsForAllPredecessors); } else if (startNodeMetadata != null) { retNode = new RunnableStartNode(nodeId); } else if (endNodeMetadata != null) { retNode = new RunnableEndNode(nodeId, endNodeMetadata.WaitsForAllPredecessors); } else if (loopMetadata != null) { retNode = CreateLoopNode(nodeId, loopMetadata, loggerNameRoot, library, componentsAppDomain, terminateExperimentExecutionResetEvent); } else if (scopeMetadata != null) { retNode = CreateScopeCompositeComponentNode(nodeId, scopeMetadata, loggerNameRoot, library, componentsAppDomain, terminateExperimentExecutionResetEvent); } else if (compositeComponentMetadata != null) { retNode = CreateCompositeComponentNode(nodeId, compositeComponentMetadata, loggerNameRoot, library, componentsAppDomain, terminateExperimentExecutionResetEvent); } else if (exitDecisionMetadata != null) { retNode = new RunnablePrimitiveNode(nodeId, exitDecisionMetadata.WaitsForAllPredecessors); } else { throw new Exceptions.InconsistentTemplateException("Could not identify node type."); } return(retNode); }
/// <summary> /// Serializes the <paramref name="metadata" />. /// </summary> /// <param name="metadata">The metadata of the component that should be serialized.</param> public string Serialize(ComponentMetadata metadata) { _writer.Clear(); _writer.AppendLine("using System;"); _writer.AppendLine("using SafetySharp.Modeling;"); _writer.AppendLine("using SafetySharp.Modeling.Faults;"); _writer.NewLine(); return SerializeRecursive(metadata); }
public void LoadAssemblyNotInCurrentDomain() { // Ensure that the assembly is not already loaded foreach (System.Reflection.Assembly assm in AppDomain.CurrentDomain.GetAssemblies()) { //Dynamic libraries generated dynamically in the process cannot access location - it would throw NotSupportedException //for example runtime assemblies Microsoft.GeneratedCode of xml serializers if (assm.IsDynamic == false) { Assert.IsFalse(assm.Location.Equals(AssemblyPath, StringComparison.CurrentCultureIgnoreCase)); } } // We don't even want it in the reflection-only context foreach (System.Reflection.Assembly assm in AppDomain.CurrentDomain.ReflectionOnlyGetAssemblies()) { Assert.IsFalse(assm.Location.Equals(AssemblyPath, StringComparison.CurrentCultureIgnoreCase)); } string id = "MockComponent"; string classname = "MockComponents.MockComponent"; //class exists and should be loaded ComponentMetadataDefinition compMetaDef = new ComponentMetadataDefinition(id, AssemblyPath, classname); ComponentMetadata compMetadata = new ComponentMetadata(compMetaDef, AppContext.BaseTestDirectory); Library.Add(compMetaDef); AppDomain testComponentsAppDomain = (new TraceLab.Core.Components.LibraryHelper(AppContext.WorkspaceInstance.TypeDirectories)).CreateDomain(id, true); try { Library.LoadComponent(compMetadata, CreateWorkspaceWrapper(compMetadata), null, testComponentsAppDomain); // Ensure that the assembly did not get loaded into the current application domain. foreach (System.Reflection.Assembly assm in AppDomain.CurrentDomain.GetAssemblies()) { //Dynamic libraries generated dynamically in the process cannot access location - it would throw NotSupportedException //for example runtime assemblies Microsoft.GeneratedCode of xml serializers if (assm.IsDynamic == false) { Assert.IsFalse(assm.Location.Equals(AssemblyPath, StringComparison.CurrentCultureIgnoreCase)); } } // We don't even want it in the reflection-only context foreach (System.Reflection.Assembly assm in AppDomain.CurrentDomain.ReflectionOnlyGetAssemblies()) { Assert.IsFalse(assm.Location.Equals(AssemblyPath, StringComparison.CurrentCultureIgnoreCase)); } } finally { LibraryHelper.DestroyDomain(testComponentsAppDomain); } }
private void SetStatus(ComponentMetadata info, ComponentStatus status) { if (info != null) { info.Status = status; _logger.Log(string.Format("Set component \"{0}\" status to \"{1}\".", info.FriendlyName, info.Status)); } else { _logger.Log("Unable to set status, Null argument provided.", LogMessageSeverity.Error); } }
public ComponentNode(string id, SerializedVertexData data) : base(id, data) { if (id == null) { throw new ArgumentNullException("id"); } if (data == null) { throw new ArgumentNullException("data"); } ID = id; ComponentMetadata metadata = data.Metadata as ComponentMetadata; }
/// <summary> /// Checks whether <paramref name="component" /> is direct or indirect subcomponent of <paramref name="parentComponent" />. /// </summary> /// <param name="component">The component that should be checked.</param> /// <param name="parentComponent">The parent component that should be checked.</param> private static bool IsSubcomponent(ComponentMetadata component, ComponentMetadata parentComponent) { var root = parentComponent.RootComponent; while (true) { if (component == parentComponent) return true; if (component == root) return false; component = component.ParentComponent; } }
// We need to filter out the duplicate tag helper descriptors that come from the // open file in the editor. We mangle the class name for its generated code, so using that here to filter these out. internal static bool IsTagHelperFromMangledClass(TagHelperDescriptor tagHelper) { StringSegment className; if (tagHelper.IsChildContentTagHelper()) { // If this is a child content tag helper, we want to look at it's original type. // E.g, if the type name is `Test.__generated__MyComponent.ChildContent`, we want to look at `Test.__generated__MyComponent`. TrySplitNamespaceAndType(tagHelper, out var typeNamespace); return(TrySplitNamespaceAndType(typeNamespace, out var _, out className) && ComponentMetadata.IsMangledClass(className)); } return(TrySplitNamespaceAndType(tagHelper, out var _, out className) && ComponentMetadata.IsMangledClass(className)); }
/// <summary> /// Transforms the <paramref name="component" /> to a <see cref="Ssm.Comp" /> instance. /// </summary> private static Ssm.Comp Transform(ComponentMetadata component) { var fields = (IEnumerable<FieldMetadata>)component.Fields; var methods = component.ProvidedPorts.Cast<MethodMetadata>().Concat(component.RequiredPorts).Concat(new[] { component.StepMethod }); if (component.StateMachine != null) { var transitions = component.StateMachine.Transitions; methods = methods.Concat(transitions.Where(transition => transition.Guard != null).Select(transition => transition.Guard).Distinct()); methods = methods.Concat(transitions.Where(transition => transition.Action != null).Select(transition => transition.Action).Distinct()); fields = fields.Concat(new[] { component.StateMachine.StateField }); } return Ssm.CreateComponent(GetComponentPath(component), fields.Select(Transform), methods.Select(Transform), component.Subcomponents.Select(Transform), component.Faults.Select(Transform), component.Bindings.Select(Transform)); }
// We need to filter out the duplicate tag helper descriptors that come from the // open file in the editor. We mangle the class name for its generated code, so using that here to filter these out. internal static bool IsTagHelperFromMangledClass(TagHelperDescriptor tagHelper) { var typeName = tagHelper.GetTypeName(); if (tagHelper.IsChildContentTagHelper()) { // If this is a child content tag helper, we want to look at it's original type. // E.g, if the type name is `Test.__generated__MyComponent.ChildContent`, we want to look at `Test.__generated__MyComponent`. TrySplitNamespaceAndType(typeName, out var namespaceTextSpan, out var _); typeName = GetTextSpanContent(namespaceTextSpan, typeName); } if (!TrySplitNamespaceAndType(typeName, out var _, out var classNameTextSpan)) { return(false); } var className = GetTextSpanContent(classNameTextSpan, typeName); return(ComponentMetadata.IsMangledClass(className)); }
public void LoadComponentClassLoaded() { string id = "MockComponent"; string classname = "MockComponents.MockComponent"; //class exists and should be loaded ComponentMetadataDefinition compMetaDef = new ComponentMetadataDefinition(id, AssemblyPath, classname); ComponentMetadata compMetadata = new ComponentMetadata(compMetaDef, AppContext.BaseTestDirectory); Library.Add(compMetaDef); AppDomain testComponentsAppDomain = (new TraceLab.Core.Components.LibraryHelper(AppContext.WorkspaceInstance.TypeDirectories)).CreateDomain(id, true); try { Library.LoadComponent(compMetadata, CreateWorkspaceWrapper(compMetadata), null, testComponentsAppDomain); } finally { LibraryHelper.DestroyDomain(testComponentsAppDomain); } }
/// <summary> /// Checks the output mappings format for illegal characters. /// In particular it assures that mappings do not contain Workspace Namespace_Delimiter character. /// </summary> /// <param name="componentMetadata">The component metadata.</param> /// <param name="errorMessage">The error message, if method returns false</param> /// <returns>true, if there are no errors, otherwise false.</returns> private static bool CheckOutputMappingFormat(ComponentMetadata componentMetadata, out string errorMessage) { bool noErrors = true; StringBuilder error = new StringBuilder(); //validate also if mappings do not contain illegal characters (in particular workspace namespace delimiter) foreach (IOItem item in componentMetadata.IOSpec.Output.Values) { if (item.MappedTo.Contains(TraceLab.Core.Workspaces.Workspace.NAMESPACE_DELIMITER)) { noErrors = false; error.AppendLine(String.Format("Output mapping '{0}' cannot contain character '{1}'", item.MappedTo, TraceLab.Core.Workspaces.Workspace.NAMESPACE_DELIMITER)); } } errorMessage = error.ToString(); return(noErrors); }
public Component(Dataflow pipeline, string moniker) { if (pipeline == null) { throw new ArgumentNullException(nameof(pipeline)); } if (string.IsNullOrWhiteSpace(moniker)) { throw new ArgumentException("Value cannot be null or whitespace.", nameof(moniker)); } Pipeline = pipeline.Pipeline; ComponentMetadata = (IDTSComponentMetaData130)Pipeline.ComponentMetaDataCollection.New(); ComponentMetadata.ComponentClassID = moniker; ManagedComponentWrapper = ComponentMetadata.Instantiate(); ManagedComponentWrapper.ProvideComponentProperties(); Connections = pipeline.Connections; }
public void ComponentUpdated(ComponentMetadata component) { this.BeginInvoke(() => { var oldComponent = Components.Where(c => c.OriginalObject.ComponentId == component.ComponentId).FirstOrDefault(); if (oldComponent != null) { oldComponent.UpdateFrom(component); } else { ComponentMetadataModel model = new ComponentMetadataModel(); model.UpdateFrom(component); model.StopCommand.ParameterizedExecuteCallback += ExecuteStopCommand; model.StartCommand.ParameterizedExecuteCallback += ExecuteStartCommand; model.RestartCommand.ParameterizedExecuteCallback += ExecuteRestartCommand; model.DisableCommand.ParameterizedExecuteCallback += ExecuteDisableCommand; Components.Add(model); } }); }
private ComponentMetadata GetMetadata(KeyValuePair <Type, Type> type) { ComponentMetadata info; if (!_metadataCache.TryGetValue(type.Key, out info)) { info = new ComponentMetadata(); info.InterfaceTypeName = type.Key.Name; info.ConcreteTypeName = type.Value.Name; var metaAtty = type.Value.GetAttribute <ComponentMetadataAttribute>(); if (metaAtty != null) { info.Description = metaAtty.Description; info.FriendlyName = metaAtty.FriendlyName; info.UserActions = metaAtty.AllowedActions; } var regAtty = type.Value.GetAttribute <ComponentRegistrationAttribute>(); if (regAtty != null) { info.Type = regAtty.Type; } //TODO: use configuration system to get the real data //info.IsDisabled = _config.GetConfig<bool>(GetType().Name,string.Format(type.Value.Name)); info.IsDisabled = false; info.Dependencies = GetDependencies(type.Value).ToArray(); info.ComponentId = info.GetHashCode(); _metadataCache.Add(type.Key, info); } return(info); }
private void AttachListenerToIOSpecHighlights(ExperimentNode node) { // HERZUM SPRINT 4: TLAB-238 ComponentMetadata meta = ExperimentNode.Data.Metadata as ComponentMetadata; if (meta != null) { TraceLab.Core.Components.ConfigWrapper configWrapper = meta.ConfigWrapper as TraceLab.Core.Components.ConfigWrapper; if (configWrapper != null) { TraceLab.Core.Components.ConfigPropertyObject value = new TraceLab.Core.Components.ConfigPropertyObject(); // HERZUM SPRINT 4.3: TLAB-238 TLAB-243 // ADD configWrapper.ConfigValues.TryGetValue ("ConfigurationFile", out value) if (configWrapper.ConfigValues.TryGetValue("Directory", out value) || configWrapper.ConfigValues.TryGetValue("ConfigurationFile", out value)) { if (value != null) { value.SetExperimentLocationRoot(System.IO.Path.GetDirectoryName(m_applicationContext.Application.Experiment.ExperimentInfo.FilePath), true); } } // END HERZUM SPRINT 4.2: TLAB-202 } } // HERZUM SPRINT 4: TLAB-238 //set convenience metadata field m_componentMetadata = node.Data.Metadata as IConfigurableAndIOSpecifiable; if (m_componentMetadata != null) { m_componentMetadata.IOSpec.PropertyChanged += (object sender, System.ComponentModel.PropertyChangedEventArgs e) => { if (e.PropertyName.Equals("IsInputHighlighted") || e.PropertyName.Equals("IsOutputHighlighted")) { //redraw component Invalidate(); } }; } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") private void addOwnedEntitiesFor(org.terasology.entitySystem.Component comp, org.terasology.entitySystem.metadata.ComponentMetadata<?> componentMetadata, java.util.Collection<org.terasology.entitySystem.entity.EntityRef> outEntityList) private void addOwnedEntitiesFor <T1>(Component comp, ComponentMetadata <T1> componentMetadata, ICollection <EntityRef> outEntityList) { foreach (ComponentFieldMetadata field in componentMetadata.Fields) { if (field.OwnedReference) { object value = field.getValue(comp); if (value is ICollection) { foreach (EntityRef @ref in ((ICollection <EntityRef>)value)) { if (@ref.exists()) { outEntityList.Add(@ref); } } } else if (value is IDictionary) { foreach (EntityRef @ref in ((IDictionary <object, EntityRef>)value).Values) { if (@ref.exists()) { outEntityList.Add(@ref); } } } else if (value is EntityRef) { EntityRef @ref = (EntityRef)value; if (@ref.exists()) { outEntityList.Add(@ref); } } } } }
private IWorkspaceInternal CreateWorkspaceWrapper(ComponentMetadata metadata) { return(WorkspaceWrapperFactory.CreateWorkspaceWrapper(metadata, WorkspaceManager.WorkspaceInternalInstance)); }
/// <summary> /// Creates the workspace wrapper, which ensures that loading and storing of workspace items has been declared by the component. /// </summary> /// <param name="originalComponentMetadata">The component metadata.</param> /// <param name="workspaceInstance">The workspace instance.</param> /// <returns>created workspace wrapper</returns> public static WorkspaceWrapper CreateWorkspaceWrapper(ComponentMetadata componentMetadata, IWorkspaceInternal workspaceInstance) { return(new WorkspaceWrapper(componentMetadata.IOSpec, workspaceInstance)); }
public void ComponentUpdated(ComponentMetadata component) { _logger.Log(string.Format("Component \"{0}\" status is now \"{1}\"", component.FriendlyName, component.Status)); }
public StatementWriter(CodeWriter writer, ComponentMetadata metadata = null) { _metadata = metadata; _writer = writer; }
public TagHelperDirectiveVisitor(IReadOnlyList <TagHelperDescriptor> tagHelpers) { // We don't want to consider components in a view document. _tagHelpers = tagHelpers.Where(t => !ComponentMetadata.IsComponentTagHelperKind(t.Kind)).ToList(); }
/// <summary> /// Extracts the components/types assemblies from the given vertex. /// </summary> /// <param name="pVertex">Vertex from the experiment graph.</param> private void ExtractFilesFromNode(ExperimentNode pVertex) { if (pVertex is ComponentNode) // Regular component { ComponentMetadata metaData = (ComponentMetadata)pVertex.Data.Metadata; if (metaData != null) { ComponentMetadataDefinition metaDataDef = metaData.ComponentMetadataDefinition; if (metaDataDef != null) { bool include; if (m_config.IncludeOtherPackagesAssemblies) { include = true; } else { //determine if component is independent or is coming from another package include = !IsAssemblyInAnotherPackage(metaDataDef.Assembly); } if (include) { // Component assembly this.m_componentAssemblies.Add(Path.GetFullPath(metaDataDef.Assembly)); // Extracting types from IOSpec ExtractTypesFromIOSpec(metaDataDef.IOSpecDefinition); } } ConfigWrapper config = metaData.ConfigWrapper; if (config != null) { // Extracting paths for files/directories from components' configuration foreach (ConfigPropertyObject configValue in config.ConfigValues.Values) { // Files if (configValue.Type == "TraceLabSDK.Component.Config.FilePath" && configValue.Value != null) { // Independent files if (configValue.Value is TraceLab.Core.Components.TraceLabFilePath == false) { if (this.m_config.IncludeIndependentFilesDirs) { var filePath = (TraceLabSDK.Component.Config.FilePath)configValue.Value; if (File.Exists(filePath.Absolute)) { PackageFileInfo packageFileInfo = new PackageFileInfo(filePath); m_files.Add(packageFileInfo); //Change config value relative path -> this path is saved within experiment (note, we operate on the experiment clone) //so that relative path is in the subfolder of Experiment folder filePath.Relative = packageFileInfo.RelativeLocation; } } } // Files contained in a package else { if (this.m_config.IncludeOtherPackagesFilesDirs) { //TraceLabFilePath represents the file reference located in the package var packageFilePath = (TraceLabFilePath)configValue.Value; if (File.Exists(packageFilePath.Absolute)) { PackageFileInfo packageFileInfo = new PackageFileInfo(packageFilePath); m_files.Add(packageFileInfo); //change the configValue to basic FilePath, (not TraceLabFilePath in the package), with updated Relative Path //so that relative path is in the subfolder of Experiment folder TraceLabSDK.Component.Config.FilePath basicFilePath = new TraceLabSDK.Component.Config.FilePath(); basicFilePath.Init(packageFilePath.Absolute, packageFilePath.DataRoot); basicFilePath.Relative = packageFileInfo.RelativeLocation; configValue.Value = basicFilePath; } } } } // Directories else if (configValue.Type == "TraceLabSDK.Component.Config.DirectoryPath" && configValue.Value != null) { // Independent directories if (configValue.Value is TraceLab.Core.Components.TraceLabDirectoryPath == false) { if (this.m_config.IncludeIndependentFilesDirs) { var dirPath = (TraceLabSDK.Component.Config.DirectoryPath)configValue.Value; if (Directory.Exists(dirPath.Absolute)) { PackageFileInfo packageDirectoryInfo = new PackageFileInfo(dirPath); m_directories.Add(packageDirectoryInfo); //Change config value relative path -> this path is saved within experiment (note, we operate on the experiment clone) //so that relative path is in the subfolder of Experiment folder dirPath.Relative = packageDirectoryInfo.RelativeLocation; } } } // Directories contained in a package else { if (this.m_config.IncludeOtherPackagesFilesDirs) { var packageDirPath = (TraceLabDirectoryPath)configValue.Value; if (Directory.Exists(packageDirPath.Absolute)) { PackageFileInfo packageDirInfo = new PackageFileInfo(packageDirPath); m_directories.Add(packageDirInfo); //change the configValue to basic FilePath, (not TraceLabFilePath in the package), with updated Relative Path //so that relative path is in the subfolder of Experiment folder TraceLabSDK.Component.Config.DirectoryPath basicFilePath = new TraceLabSDK.Component.Config.DirectoryPath(); basicFilePath.Init(packageDirPath.Absolute, packageDirPath.DataRoot); basicFilePath.Relative = packageDirInfo.RelativeLocation; configValue.Value = basicFilePath; } } } } } } } } else if (pVertex is CompositeComponentNode) // Composite Components, Loops & Scopes { CompositeComponentBaseMetadata metaData = (CompositeComponentBaseMetadata)pVertex.Data.Metadata; if (metaData != null) { foreach (var vertex in metaData.ComponentGraph.Vertices) { ExtractFilesFromNode(vertex); } // Only composite components have MetadataDefinition if (pVertex.Data.Metadata is CompositeComponentMetadata) { CompositeComponentMetadataDefinition metaDataDefinition = ((CompositeComponentMetadata)pVertex.Data.Metadata).ComponentMetadataDefinition; this.m_componentAssemblies.Add(Path.GetFullPath(metaDataDefinition.Assembly)); // Extracting types from IOSpec ExtractTypesFromIOSpec(metaDataDefinition.IOSpecDefinition); } } } }
/// <summary> /// Returns a string representation of a component path leading to <paramref name="component" />. /// </summary> private static string GetComponentPath(ComponentMetadata component) { return String.Join(".", component.GetPath()); }
private void WriteMemberAccess(ComponentMetadata component) { if (component == _metadata) _writer.Append("this."); else { WriteMemberAccess(component.ParentComponent); _writer.Append("_{0}.", component.Name); } }
/// <inheritdoc /> protected override void OnDocumentStructureCreated( RazorCodeDocument codeDocument, NamespaceDeclarationIntermediateNode @namespace, ClassDeclarationIntermediateNode @class, MethodDeclarationIntermediateNode method) { if (!codeDocument.TryComputeNamespace(fallbackToRootNamespace: true, out var computedNamespace) || !TryComputeClassName(codeDocument, out var computedClass)) { // If we can't compute a nice namespace (no relative path) then just generate something // mangled. computedNamespace = FallbackRootNamespace; var checksum = Checksum.BytesToString(codeDocument.Source.GetChecksum()); computedClass = $"AspNetCore_{checksum}"; } var documentNode = codeDocument.GetDocumentIntermediateNode(); if (char.IsLower(computedClass, 0)) { // We don't allow component names to start with a lowercase character. documentNode.Diagnostics.Add( ComponentDiagnosticFactory.Create_ComponentNamesCannotStartWithLowerCase(computedClass, documentNode.Source)); } if (MangleClassNames) { computedClass = ComponentMetadata.MangleClassName(computedClass); } @namespace.Content = computedNamespace; @class.ClassName = computedClass; @class.Modifiers.Clear(); @class.Modifiers.Add("public"); @class.Modifiers.Add("partial"); if (FileKinds.IsComponentImport(codeDocument.GetFileKind())) { // We don't want component imports to be considered as real component. // But we still want to generate code for it so we can get diagnostics. @class.BaseType = typeof(object).FullName; method.ReturnType = "void"; method.MethodName = "Execute"; method.Modifiers.Clear(); method.Modifiers.Add("protected"); method.Parameters.Clear(); } else { @class.BaseType = ComponentsApi.ComponentBase.FullTypeName; // Constrained type parameters are only supported in Razor language versions v6.0 var razorLanguageVersion = codeDocument.GetParserOptions()?.Version ?? RazorLanguageVersion.Latest; var directiveType = razorLanguageVersion.CompareTo(RazorLanguageVersion.Version_6_0) >= 0 ? ComponentConstrainedTypeParamDirective.Directive : ComponentTypeParamDirective.Directive; var typeParamReferences = documentNode.FindDirectiveReferences(directiveType); for (var i = 0; i < typeParamReferences.Count; i++) { var typeParamNode = (DirectiveIntermediateNode)typeParamReferences[i].Node; if (typeParamNode.HasDiagnostics) { continue; } @class.TypeParameters.Add(new TypeParameter() { ParameterName = typeParamNode.Tokens.First().Content, Constraints = typeParamNode.Tokens.Skip(1).FirstOrDefault()?.Content }); } method.ReturnType = "void"; method.MethodName = ComponentsApi.ComponentBase.BuildRenderTree; method.Modifiers.Clear(); method.Modifiers.Add("protected"); method.Modifiers.Add("override"); method.Parameters.Clear(); method.Parameters.Add(new MethodParameter() { ParameterName = ComponentsApi.RenderTreeBuilder.BuilderParameter, TypeName = ComponentsApi.RenderTreeBuilder.FullTypeName, }); } }
/// <summary> /// Serializes the <paramref name="metadata" />. /// </summary> /// <param name="metadata">The metadata of the component that should be serialized.</param> private string SerializeRecursive(ComponentMetadata metadata) { _writer.AppendLine("public class {0} : Component", metadata.Name ?? "C"); _writer.AppendBlockStatement(() => { var statementWriter = new StatementWriter(_writer, metadata); foreach (var field in metadata.Fields) _writer.AppendLine("public {0} {1};", field.Type.FullName, field.Name); foreach (var port in metadata.RequiredPorts) { _writer.AppendLine("public extern {0} {1}({2});", ReturnType(port.MethodInfo.ReturnType), port.Name, String.Join(", ", port.MethodInfo.GetParameters().Select(Parameter))); } foreach (var port in metadata.ProvidedPorts) { _writer.AppendLine("public {0} {1}({2})", ReturnType(port.MethodInfo.ReturnType), port.Name, String.Join(", ", port.MethodInfo.GetParameters().Select(Parameter))); statementWriter.Visit(port.MethodBody); } _writer.AppendLine("public override void Update()"); statementWriter.Visit(metadata.StepMethod.MethodBody); foreach (var subcomponent in metadata.Subcomponents) { SerializeRecursive(subcomponent); _writer.AppendLine("public {0} _{0} = new {0}();", subcomponent.Name); } _writer.AppendLine("public {0}()", metadata.Name ?? "C"); _writer.AppendBlockStatement(() => { foreach (var binding in metadata.Bindings) _writer.AppendLine("Bind(RequiredPorts.{0} = ProvidedPorts.{1});", binding.RequiredPort.Name, binding.ProvidedPort.Name); foreach (var field in metadata.Fields) { string values = null; if (field.Type == typeof(int)) values = String.Join(", ", field.InitialValues); if (field.Type == typeof(bool)) values = String.Join(", ", field.InitialValues.Select(v => v.ToString().ToLower())); if (field.Type == typeof(double)) values = String.Join(", ", field.InitialValues.Select(v => ((double)v).ToString(CultureInfo.InvariantCulture))); if (field.Type.IsEnum) values = String.Join(", ", field.InitialValues.Select(v => String.Format("{0}.{1}", field.Type.Name, Enum.GetValues(field.Type).Cast<object>().First()))); _writer.AppendLine("SetInitialValues({0}, {1});", field.Name, values); } }); foreach (var enumeration in statementWriter.Enums.Union(metadata.Fields.Where(f => f.Type.IsEnum).Select(f => f.Type))) { var values = String.Join(", ", Enum.GetValues(enumeration).Cast<object>().Select(v => v.ToString())); _writer.AppendLine("public enum {0} {{ {1} }}", enumeration.Name, values); } }); return _writer.ToString(); }
private IWorkspaceInternal CreateWorkspaceWrapper(ComponentMetadata metadata) { return WorkspaceWrapperFactory.CreateWorkspaceWrapper(metadata, WorkspaceManager.WorkspaceInternalInstance); }