/// <summary> /// Create an instance of a LoggingService and returns is as an IBuildComponent /// </summary> /// <returns>An instance of a LoggingService as a IBuildComponent</returns> public IBuildComponent CreateInstance(BuildComponentType type) { ErrorUtilities.VerifyThrow(type == BuildComponentType.LoggingService, "Cannot create components of type {0}", type); IBuildComponent loggingService = (IBuildComponent)LoggingService.CreateLoggingService(_logMode, _nodeId); return(loggingService); }
public void InitializeComponentNullHost() { Assert.Throws <InternalErrorException>(() => { IBuildComponent logServiceComponent = (IBuildComponent)LoggingService.CreateLoggingService(LoggerMode.Synchronous, 1); logServiceComponent.InitializeComponent(null); } ); }
/// <summary> /// Create a TestExtension for a given component type. /// </summary> /// <param name="componentName">Name of the component for which the TestExtension is to be created.</param> /// <param name="testExtensionName">Fully qualified TestExtension name.</param> /// <param name="buildManagerTestExtension">BuildManager Test extension entry.</param> /// <returns>New TestExtension.</returns> private static TestExtension CreateTestExtensionForComponent(string componentName, string testExtensionName, BuildManagerTestExtension buildManagerTestExtension) { BuildComponentType type = StringToEnum <BuildComponentType>(componentName); IBuildComponent component = buildManagerTestExtension.GetComponent(type); Type testExtensionType = Assembly.GetAssembly(typeof(BuildManagerContainerGenerator)).GetType(testExtensionName, true, true); object[] parameters = { component }; return((TestExtension)testExtensionType.InvokeMember(null, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.CreateInstance, null, null, parameters, CultureInfo.InvariantCulture)); }
/// <summary> /// Shuts down the single instance for this component type. /// </summary> public void ShutdownSingletonInstance() { ErrorUtilities.VerifyThrow(Pattern == CreationPattern.Singleton, "Cannot shutdown non-singleton."); if (_singleton != null) { _singleton.ShutdownComponent(); _singleton = null; } }
/// <summary> /// Set the value of a component type on this context. /// NOTE: The build configuration asset is not modified. /// </summary> /// <param name="type"><see cref="Type"/> of the component.</param> /// <param name="value">Value of the component to set.</param> public void SetComponent(Type type, IBuildComponent value) { BuildConfiguration.ValidateComponentTypeAndThrow(type); if (type.IsInterface || type.IsAbstract) { throw new InvalidOperationException($"{nameof(type)} cannot be interface or abstract."); } m_Components[type] = value; }
public void AddInput(IBuildComponent component) { if (component.ConsumedBy != null) { throw new InvalidOperationException("Component is already consumed by a build step."); } component.ConsumedBy = this; m_consumes.Add(component); }
private KitBuildItem CreateKitBuildItemNode(IBuildComponent buildComponent) { var fabricStyles = new FabricStyleList(); foreach (var style in buildComponent.FabricStyles) { fabricStyles.Add(new FabricStyle(style.Sku, style.Color)); } return(new KitBuildItemNode(buildComponent.Id, buildComponent.Quantity, buildComponent.ComponentType, buildComponent.ComponentSubtype, fabricStyles, buildComponent.Area, buildComponent.Node)); }
/// <summary> /// Try to get the value of a component type. /// Throws if component type is not in UsedComponents list. /// </summary> /// <param name="type">The component type.</param> /// <param name="value">The component value.</param> /// <returns><see langword="true"/> if the component is found, otherwise <see langword="false"/>.</returns> public bool TryGetComponent(Type type, out IBuildComponent value) { ValidateUsedComponentTypesAndThrow(type); BuildConfiguration.ValidateComponentTypeAndThrow(type); if (m_Components.TryGetValue(type, out value)) { return(true); } return(BuildConfiguration.TryGetComponent(type, out value)); }
private IBuildStep FindOrCreateStep(IBuildComponent component) { var styleKey = component.StyleKey; var result = m_pendingSteps.Where(r => r.CanProduceQuantity(styleKey) >= component.Quantity).FirstOrDefault(); if (result == null) { result = m_pendingSteps.Where(r => r.CanProduceQuantity(styleKey) > 0).FirstOrDefault(); } if (result == null) { var styleType = styleKey.Substring(0, styleKey.IndexOf(BuildComponent.StyleKeyDelimiter)); switch (styleType) { case nameof(BuildComponentQuilt): result = new BuildStepAssembleQuilt(styleKey); break; case nameof(BuildComponentLayout): result = new BuildStepAssembleLayout(styleKey); break; case nameof(BuildComponentFlyingGoose): result = new BuildStepFlyingGoose(styleKey); break; case nameof(BuildComponentHalfSquareTriangle): result = new BuildStepHalfSquareTriangle(styleKey); break; case nameof(BuildComponentRectangle): result = new BuildStepCut(styleKey); break; case nameof(BuildComponentYardage): // Source component - no build step required. // return(null); default: throw new InvalidOperationException(string.Format("No build step for style type {0}.", styleType)); } m_allSteps.Add(result); m_pendingSteps.Add(result); } return(result); }
/// <summary> /// Instantiate and Initialize a new loggingService. /// This is used by the test setup method to create /// a new logging service before each test. /// </summary> private void InitializeLoggingService() { BuildParameters parameters = new BuildParameters(); parameters.MaxNodeCount = 2; MockHost mockHost = new MockHost(parameters); IBuildComponent logServiceComponent = (IBuildComponent)LoggingService.CreateLoggingService(LoggerMode.Synchronous, 1); logServiceComponent.InitializeComponent(mockHost); _initializedService = logServiceComponent as LoggingService; }
/// <summary> /// Try to get the value of a component type. /// Throws if component type is not in UsedComponents list. /// </summary> /// <param name="type">The component type.</param> /// <param name="value">The component value.</param> /// <returns><see langword="true"/> if the component is found, otherwise <see langword="false"/>.</returns> public bool TryGetComponent(Type type, out IBuildComponent value) { CheckUsedComponentTypesAndThrowIfMissing(type); BuildConfiguration.CheckComponentTypeAndThrowIfInvalid(type); if (m_Components.TryGetValue(type, out value)) { return(true); } return(BuildConfiguration.TryGetComponent(type, out value)); }
public void AddOutput(IBuildComponent component) { if (component.ProducedBy != null) { throw new InvalidOperationException("Component is already produced by a build step."); } if (CanProduceQuantity(component.StyleKey) == 0) { throw new InvalidOperationException("Build step does not produce desired style."); } component.ProducedBy = this; m_produces.Add(component); }
private void ProcessComponent(IBuildComponent component, BuildComponentFactory factory) { var step = FindOrCreateStep(component); if (step != null) { int quantity = step.CanProduceQuantity(component.StyleKey); if (quantity < component.Quantity) { var splitComponent = component.Split(factory, component.Quantity - quantity); PushPendingComponent(splitComponent); } step.AddOutput(component); } }
public virtual void WriteBuildConfiguration(BuildContext context, string path) { var componentTypes = new HashSet <Type>(); foreach (var usedComponent in context.UsedComponents) { if (usedComponent.IsAbstract || usedComponent.IsInterface) { var derivedComponents = TypeCache.GetTypesDerivedFrom(usedComponent); foreach (var derivedComponent in derivedComponents) { if (derivedComponent.IsAbstract || derivedComponent.IsInterface) { continue; } componentTypes.Add(derivedComponent); } } else { componentTypes.Add(usedComponent); } } var realComponents = new List <IBuildComponent>(); var defaultComponents = new List <IBuildComponent>(); foreach (var componentType in componentTypes) { var component = context.GetComponentOrDefault(componentType); if (context.HasComponent(componentType)) { realComponents.Add(component); } else { defaultComponents.Add(component); } } var components = new IBuildComponent[][] { realComponents.ToArray(), defaultComponents.ToArray() }; var json = JsonSerialization.ToJson(components); File.WriteAllText(Path.Combine(path, "buildconfiguration.json"), json); }
/// <summary> /// Gets an instance of the component. /// </summary> public IBuildComponent GetInstance(IBuildComponentHost host) { if (Pattern == CreationPattern.Singleton) { if (_singleton == null) { _singleton = _factory(ComponentType); _singleton.InitializeComponent(host); } return(_singleton); } IBuildComponent component = _factory(ComponentType); component.InitializeComponent(host); return(component); }
public void InitializeComponent() { IBuildComponent logServiceComponent = (IBuildComponent)LoggingService.CreateLoggingService(LoggerMode.Synchronous, 1); BuildParameters parameters = new BuildParameters(); parameters.MaxNodeCount = 4; parameters.OnlyLogCriticalEvents = true; IBuildComponentHost loggingHost = new MockHost(parameters); // Make sure we are in the Instantiated state before initializing Assert.Equal(((LoggingService)logServiceComponent).ServiceState, LoggingServiceState.Instantiated); logServiceComponent.InitializeComponent(loggingHost); // Makesure that the parameters in the host are set in the logging service LoggingService service = (LoggingService)logServiceComponent; Assert.Equal(service.ServiceState, LoggingServiceState.Initialized); Assert.Equal(4, service.MaxCPUCount); Assert.True(service.OnlyLogCriticalEvents); }
public virtual void WriteBuildConfiguration(BuildContext context, string path) { var realComponents = new List <IBuildComponent>(); var defaultComponents = new List <IBuildComponent>(); foreach (var c in UsedComponents) { var component = context.GetComponentOrDefault(c); if (context.HasComponent(c)) { realComponents.Add(component); } else { defaultComponents.Add(component); } } var components = new IBuildComponent[][] { realComponents.ToArray(), defaultComponents.ToArray() }; var json = JsonSerialization.ToJson(components); File.WriteAllText(Path.Combine(path, "buildconfiguration.json"), json); }
public void CreateLogger() { // Generic host which has some default properties set inside of it IBuildComponent logServiceComponent = (IBuildComponent)LoggingService.CreateLoggingService(LoggerMode.Synchronous, 1); // Create a synchronous logging service and do some quick checks Assert.NotNull(logServiceComponent); LoggingService logService = (LoggingService)logServiceComponent; Assert.Equal(logService.LoggingMode, LoggerMode.Synchronous); Assert.Equal(logService.ServiceState, LoggingServiceState.Instantiated); // Create an asynchronous logging service logServiceComponent = (IBuildComponent)LoggingService.CreateLoggingService(LoggerMode.Asynchronous, 1); Assert.NotNull(logServiceComponent); logService = (LoggingService)logServiceComponent; Assert.Equal(logService.LoggingMode, LoggerMode.Asynchronous); Assert.Equal(logService.ServiceState, LoggingServiceState.Instantiated); // Shutdown logging thread logServiceComponent.InitializeComponent(new MockHost()); logServiceComponent.ShutdownComponent(); Assert.Equal(logService.ServiceState, LoggingServiceState.Shutdown); }
public BuildComponentInspectorData(BuildConfigurationInspectorData config, IBuildComponent value) { m_Config = config; ComponentType = value.GetType(); ComponentSource = config.GetComponentSource(ComponentType); IsComponentPresent = config.HasComponent(ComponentType); IsComponentInherited = config.IsComponentInherited(ComponentType); IsComponentOverriding = config.IsComponentOverriding(ComponentType); IsComponentUsed = config.IsComponentUsed(ComponentType); ConfigHasPipeline = config.HasPipeline; ComponentName = ObjectNames.NicifyVariableName(ComponentType.Name); var visitor = new ComponentVisitor(); PropertyContainer.Visit(ref value, visitor); FieldNames = visitor.FieldNames; IsPipelineComponent = typeof(IBuildPipelineComponent).IsAssignableFrom(ComponentType); IsTagComponent = FieldNames.Length == 0; Icon = Resources.BuildComponentIcon; Value = value; }
/// <summary> /// Registers a factory to replace one of the defaults. Creation pattern is inherited from the original. /// </summary> /// <param name="componentType">The type which is created by this factory.</param> /// <param name="instance">The instance to be registered.</param> public void ReplaceFactory(BuildComponentType componentType, IBuildComponent instance) { ErrorUtilities.VerifyThrow(_componentEntriesByType[componentType].Pattern == CreationPattern.Singleton, "Previously existing factory for type {0} was not a singleton factory.", componentType); _componentEntriesByType[componentType] = new BuildComponentEntry(componentType, instance); }
#pragma warning disable IDE0051 // Remove unused private members private IBuildComponent Split(BuildComponentFactory factory, IBuildComponent component, int quantity) #pragma warning restore IDE0051 // Remove unused private members { return(component.Split(factory, quantity)); }
private void PushPendingComponent(IBuildComponent component) { m_allComponents.Add(component); m_pendingComponents.Add(component); }
private KitBuildItem CreateKitBuildItem(IBuildComponent buildComponent) { return(buildComponent is BuildComponentYardage buildComponentYardage ? CreateKitBuildItemPattern(buildComponentYardage) : CreateKitBuildItemNode(buildComponent)); }
/// <summary> /// Constructor for existing singleton. /// </summary> public BuildComponentEntry(BuildComponentType type, IBuildComponent singleton) { ComponentType = type; _singleton = singleton; Pattern = CreationPattern.Singleton; }
public void SetComponent(IBuildComponent value) { Target.SetComponent(value); }
/// <summary> /// Constructor for existing singleton. /// </summary> public BuildComponentEntry(BuildComponentType type, IBuildComponent singleton) { _singleton = singleton; this.Pattern = CreationPattern.Singleton; }
/// <summary> /// Gets an instance of the component. /// </summary> public IBuildComponent GetInstance(IBuildComponentHost host) { if (Pattern == CreationPattern.Singleton) { if (_singleton == null) { _singleton = _factory(ComponentType); _singleton.InitializeComponent(host); } return _singleton; } else { IBuildComponent component = _factory(ComponentType); component.InitializeComponent(host); return component; } }
public void SetComponent(IBuildComponent value) { m_Config.SetComponent(value); Update(); // Update since we're not rebuilding }
public void InitializeComponentNullHost() { IBuildComponent logServiceComponent = (IBuildComponent)LoggingService.CreateLoggingService(LoggerMode.Synchronous, 1); logServiceComponent.InitializeComponent(null); }
/// <summary> /// Constructs and returns a component of the specified type. /// </summary> public IBuildComponent GetComponent(BuildComponentType type) { IBuildComponent returnComponent = null; switch (type) { case BuildComponentType.LoggingService: // Singleton return((IBuildComponent)this.loggingService); case BuildComponentType.TestDataProvider: // Singleton if (this.testDataProvider != null) { return((IBuildComponent)this.testDataProvider); } returnComponent = this.getComponentCallback(type); if (returnComponent != null) { returnComponent.InitializeComponent(this); this.testDataProvider = (ITestDataProvider)returnComponent; } break; case BuildComponentType.RequestEngine: // Singleton if (this.requestEngine != null) { return((IBuildComponent)this.requestEngine); } returnComponent = this.getComponentCallback(type); if (returnComponent != null) { returnComponent.InitializeComponent(this); this.requestEngine = (IBuildRequestEngine)returnComponent; this.requestEngine.OnEngineException += new EngineExceptionDelegate(RequestEngine_OnEngineException); this.requestEngine.OnNewConfigurationRequest += new NewConfigurationRequestDelegate(RequestEngine_OnNewConfigurationRequest); this.requestEngine.OnRequestBlocked += new RequestBlockedDelegate(RequestEngine_OnNewRequest); this.requestEngine.OnRequestComplete += new RequestCompleteDelegate(RequestEngine_OnRequestComplete); this.requestEngine.OnStatusChanged += new EngineStatusChangedDelegate(RequestEngine_OnStatusChanged); } break; default: returnComponent = this.getComponentCallback(type); if (returnComponent != null) { returnComponent.InitializeComponent(this); } break; } if (returnComponent != null) { lock (this.buildComponents) { this.buildComponents.Enqueue(returnComponent); } } return(returnComponent); }