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;
}
/// <summary>
/// Validates the specified <see cref="IHyperNodeConfiguration"/> object.
/// </summary>
/// <param name="config"><see cref="IHyperNodeConfiguration"/> object to validate.</param>
public void ValidateConfiguration(IHyperNodeConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
var configClassName = config.GetType().FullName;
if (string.IsNullOrWhiteSpace(config.HyperNodeName))
{
RaiseValidationEvent(
new HyperNodeConfigurationException($"The HyperNodeName property is required for {configClassName}.")
);
}
// TaskIdProviderType is not required, but if it is specified, it must implement the correct interface
if (!string.IsNullOrWhiteSpace(config.TaskIdProviderType))
{
ValidateTypeImplementsInterface(config.TaskIdProviderType, typeof(ITaskIdProvider));
}
// HyperNodeEventHandlerType is not required, but if it is specified, it must implement the correct interface
if (!string.IsNullOrWhiteSpace(config.HyperNodeEventHandlerType))
{
ValidateTypeImplementsInterface(config.HyperNodeEventHandlerType, typeof(IHyperNodeEventHandler));
}
if (config.ActivityMonitors != null)
{
foreach (var activityMonitor in config.ActivityMonitors)
{
ValidateConfiguration(activityMonitor);
}
}
if (config.SystemCommands != null)
{
foreach (var systemCommand in config.SystemCommands)
{
ValidateConfiguration(systemCommand);
}
}
if (config.CommandModules != null)
{
// RequestSerializerType property is not required at the collection level, but if it is specified, it must implement the correct interface
if (!string.IsNullOrWhiteSpace(config.CommandModules.RequestSerializerType))
{
ValidateTypeImplementsInterface(config.CommandModules.RequestSerializerType, typeof(ICommandRequestSerializer));
}
// ResponseSerializerType property is not required at the collection level, but if it is specified, it must implement the correct interface
if (!string.IsNullOrWhiteSpace(config.CommandModules.ResponseSerializerType))
{
ValidateTypeImplementsInterface(config.CommandModules.ResponseSerializerType, typeof(ICommandResponseSerializer));
}
foreach (var commandModule in config.CommandModules)
{
ValidateConfiguration(commandModule);
}
}
}
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);
}
}
}
public HyperNodeMockConfigurationProvider(IHyperNodeConfiguration config)
{
_config = config;
}
