private static void ConfigureActivityMonitors(HyperNodeService service, IHyperNodeConfiguration config) { // Consider a null collection equivalent to an empty one if (config.ActivityMonitors == null) { return; } // Instantiate our activity monitors foreach (var monitorConfig in config.ActivityMonitors) { // If we have any problems creating the instance or casting to HyperNodeServiceActivityMonitor, we deliberately want to fail out and make them fix the config var monitor = (HyperNodeServiceActivityMonitor)Activator.CreateInstance(Type.GetType(monitorConfig.MonitorType, true)); if (monitor != null) { monitor.Name = monitorConfig.MonitorName; monitor.Enabled = monitorConfig.Enabled; monitor.Initialize(); if (service._customActivityMonitors.Any(m => m.Name == monitorConfig.MonitorName)) { throw new DuplicateActivityMonitorException( $"An activity monitor already exists with the {nameof(monitorConfig.MonitorName)} '{monitorConfig.MonitorName}'." ); } service._customActivityMonitors.Add(monitor); } } }
private static void ConfigureHyperNodeEventHandler(HyperNodeService service, IHyperNodeConfiguration config) { IHyperNodeEventHandler eventHandler = null; // Set our event handler if applicable, but if we have any problems creating the instance or casting to HyperNodeEventHandlerBase, we deliberately want to fail out and make them fix the configuration if (!string.IsNullOrWhiteSpace(config.HyperNodeEventHandlerType)) { eventHandler = (IHyperNodeEventHandler)Activator.CreateInstance(Type.GetType(config.HyperNodeEventHandlerType, true)); eventHandler.Initialize(); } service.EventHandler = eventHandler ?? DefaultEventHandler; }
private static void ConfigureTaskProvider(HyperNodeService service, IHyperNodeConfiguration config) { ITaskIdProvider taskIdProvider = null; // Set our task id provider if applicable, but if we have any problems creating the instance or casting to ITaskIdProvider, we deliberately want to fail out and make them fix the configuration if (!string.IsNullOrWhiteSpace(config.TaskIdProviderType)) { taskIdProvider = (ITaskIdProvider)Activator.CreateInstance(Type.GetType(config.TaskIdProviderType, true)); taskIdProvider.Initialize(); } service.TaskIdProvider = taskIdProvider ?? DefaultTaskIdProvider; }
private static HyperNodeService Create(IHyperNodeConfigurationProvider configProvider) { if (configProvider == null) { throw new ArgumentNullException(nameof(configProvider)); } IHyperNodeConfiguration config; try { config = configProvider.GetConfiguration(); } catch (Exception ex) { throw new HyperNodeConfigurationException( $"An exception was thrown while attempting to retrieve the configuration for this {typeof (HyperNodeService).FullName} using {configProvider.GetType().FullName}. See inner exception for details.", ex ); } // Validate our configuration var builder = new StringBuilder(); new HyperNodeConfigurationValidator( (sender, args) => builder.AppendLine(args.Message) ).ValidateConfiguration(config); // Check for validation errors before proceeding to create and configure our HyperNodeService instance if (builder.Length > 0) { throw new HyperNodeConfigurationException(builder.ToString()); } var service = new HyperNodeService(config.HyperNodeName) { EnableTaskProgressCache = config.EnableTaskProgressCache ?? DefaultTaskProgressCacheEnabled, EnableDiagnostics = config.EnableDiagnostics ?? DefaultDiagnosticsEnabled, TaskProgressCacheDuration = TimeSpan.FromMinutes(config.TaskProgressCacheDurationMinutes ?? DefaultProgressCacheDurationMinutes), MaxConcurrentTasks = config.MaxConcurrentTasks ?? DefaultMaxConcurrentTasks }; ConfigureSystemCommands(service, config); ConfigureTaskProvider(service, config); ConfigureActivityMonitors(service, config); ConfigureCommandModules(service, config); ConfigureHyperNodeEventHandler(service, config); return(service); }
private static void ConfigureSystemCommands(HyperNodeService service, IHyperNodeConfiguration config) { // Grab our user-defined default for system commands being enabled or disabled bool?userDefinedSystemCommandsEnabledDefault = null; var systemCommandsCollection = config.SystemCommands; if (systemCommandsCollection != null) { userDefinedSystemCommandsEnabledDefault = systemCommandsCollection.Enabled; } // If the user didn't configure the system commands, they will be on by default (so that we can get task statuses and such) var actualDefaultEnabled = userDefinedSystemCommandsEnabledDefault ?? true; // Make all commands enabled or disabled according to the user-defined default, or the HyperNode's default if the user did not define a default var systemCommandConfigs = new List <CommandModuleConfiguration> { new CommandModuleConfiguration { CommandName = SystemCommandName.GetCachedTaskProgressInfo, Enabled = actualDefaultEnabled, CommandModuleType = typeof(GetCachedTaskProgressInfoCommand) }, new CommandModuleConfiguration { CommandName = SystemCommandName.GetNodeStatus, Enabled = actualDefaultEnabled, CommandModuleType = typeof(GetNodeStatusCommand) }, new CommandModuleConfiguration { CommandName = SystemCommandName.GetChildNodes, Enabled = actualDefaultEnabled, CommandModuleType = typeof(GetChildNodesCommand) }, new CommandModuleConfiguration { CommandName = SystemCommandName.Echo, Enabled = actualDefaultEnabled, CommandModuleType = typeof(EchoCommand) }, new CommandModuleConfiguration { CommandName = SystemCommandName.EnableCommand, Enabled = actualDefaultEnabled, CommandModuleType = typeof(EnableCommandModuleCommand) }, new CommandModuleConfiguration { CommandName = SystemCommandName.EnableActivityMonitor, Enabled = actualDefaultEnabled, CommandModuleType = typeof(EnableActivityMonitorCommand) }, new CommandModuleConfiguration { CommandName = SystemCommandName.RenameActivityMonitor, Enabled = actualDefaultEnabled, CommandModuleType = typeof(RenameActivityMonitorCommand) }, new CommandModuleConfiguration { CommandName = SystemCommandName.EnableTaskProgressCache, Enabled = actualDefaultEnabled, CommandModuleType = typeof(EnableTaskProgressCacheCommand) }, new CommandModuleConfiguration { CommandName = SystemCommandName.EnableDiagnostics, Enabled = actualDefaultEnabled, CommandModuleType = typeof(EnableDiagnosticsCommand) }, new CommandModuleConfiguration { CommandName = SystemCommandName.CancelTask, Enabled = actualDefaultEnabled, CommandModuleType = typeof(CancelTaskCommand) }, new CommandModuleConfiguration { CommandName = SystemCommandName.SetTaskProgressCacheDuration, Enabled = actualDefaultEnabled, CommandModuleType = typeof(SetTaskProgressCacheDurationCommand) } }; foreach (var systemCommandConfig in systemCommandConfigs) { // Allow each system command to be enabled or disabled individually. This takes precedence over any defaults defined previously if (config.SystemCommands != null && config.SystemCommands.ContainsCommandName(systemCommandConfig.CommandName)) { var userConfig = config.SystemCommands.GetByCommandName(systemCommandConfig.CommandName); if (userConfig != null) { systemCommandConfig.Enabled = userConfig.Enabled; } } // Finally, try to add this system command to our collection service.AddCommandModuleConfiguration(systemCommandConfig); } }
private static void ConfigureCommandModules(HyperNodeService service, IHyperNodeConfiguration config) { // Consider a null collection equivalent to an empty one if (config.CommandModules == null) { return; } Type collectionRequestSerializerType = null; Type collectionResponseSerializerType = null; // First, see if we have any serializer types defined at the collection level if (!string.IsNullOrWhiteSpace(config.CommandModules.RequestSerializerType)) { collectionRequestSerializerType = Type.GetType(config.CommandModules.RequestSerializerType, true); } if (!string.IsNullOrWhiteSpace(config.CommandModules.ResponseSerializerType)) { collectionResponseSerializerType = Type.GetType(config.CommandModules.ResponseSerializerType, true); } foreach (var commandModuleConfig in config.CommandModules) { var commandModuleType = Type.GetType(commandModuleConfig.CommandModuleType, true); if (commandModuleType.GetInterfaces().Contains(typeof(ICommandModule))) { Type commandRequestSerializerType = null; Type commandResponseSerializerType = null; // Now check to see if we have any serializer types defined at the command level if (!string.IsNullOrWhiteSpace(commandModuleConfig.RequestSerializerType)) { commandRequestSerializerType = Type.GetType(commandModuleConfig.RequestSerializerType, true); } if (!string.IsNullOrWhiteSpace(commandModuleConfig.ResponseSerializerType)) { commandResponseSerializerType = Type.GetType(commandModuleConfig.ResponseSerializerType, true); } // Our final configuration allows command-level serializer types to take precedence, if available. Otherwise, the collection-level types are used. var configRequestSerializerType = commandRequestSerializerType ?? collectionRequestSerializerType; var configResponseSerializerType = commandResponseSerializerType ?? collectionResponseSerializerType; ICommandRequestSerializer configRequestSerializer = null; ICommandResponseSerializer configResponseSerializer = null; // Attempt construction of config-level serializer types if (configRequestSerializerType != null) { configRequestSerializer = (ICommandRequestSerializer)Activator.CreateInstance(configRequestSerializerType); } if (configResponseSerializerType != null) { configResponseSerializer = (ICommandResponseSerializer)Activator.CreateInstance(configResponseSerializerType); } // Finally, construct our command module configuration var commandConfig = new CommandModuleConfiguration { CommandName = commandModuleConfig.CommandName, Enabled = commandModuleConfig.Enabled, CommandModuleType = commandModuleType, RequestSerializer = configRequestSerializer ?? DefaultRequestSerializer, ResponseSerializer = configResponseSerializer ?? DefaultResponseSerializer }; service.AddCommandModuleConfiguration(commandConfig); } } }