public AggregateAnnotationCommandHandler(IRepository <T> repository,
ICommandTargetResolver commandTargetResolver,
IParameterResolverFactory parameterResolverFactory,
IHandlerDefinition handlerDefinition)
: this(repository, commandTargetResolver, AnnotatedAggregateMetaModelFactory.InspectAggregate(typeof(T), parameterResolverFactory, handlerDefinition))
{
}
public AnnotationCommandHandlerAdapter(object annotatedCommandHandler,
IParameterResolverFactory parameterResolverFactory,
IHandlerDefinition handlerDefinition)
{
Assert.NotNull(annotatedCommandHandler, () => "annotatedCommandHandler may not be null");
_modelInspector = AnnotatedAggregateMetaModelFactory.InspectAggregate(annotatedCommandHandler.GetType(), parameterResolverFactory, handlerDefinition);
_target = annotatedCommandHandler;
}
public AnnotatedHandlerInspector(Type inspectedType, List <AnnotatedHandlerInspector> superClassInspectors, IParameterResolverFactory parameterResolverFactory, IHandlerDefinition handlerDefinition, Dictionary <Type, AnnotatedHandlerInspector> registry)
{
_inspectedType = inspectedType;
_parameterResolverFactory = parameterResolverFactory;
_registry = registry;
_superClassInspectors = superClassInspectors;
Handlers = new List <IMessageHandlingMember>();
_handlerDefinition = handlerDefinition;
}
/// <summary>
/// Constructor which creates the TrafficHandler, the configuration reader and writer and the TrafficHandler ports.
/// </summary>
/// <param name="hdDefinition">The HandlerDefinition which is associated with this HandlerController.</param>
/// <param name="env">The environment to associate this controller with</param>
/// <param name="param">A parameter which is provided to all creation-methods of the subclass</param>
protected HandlerController(IHandlerDefinition hdDefinition, IEnvironment env, object param)
{
Environment = env;
TrafficHandler = Create(param);
ConfigurationLoader = CreateConfigurationLoader(TrafficHandler, param);
ConfigurationWriter = CreateConfigurationWriter(TrafficHandler, param);
TrafficHandlerPorts = CreateTrafficHandlerPorts(TrafficHandler, param);
BaseDefinition = hdDefinition;
Name = BaseDefinition.Name;
Properties = new Dictionary <string, object>();
}
private static AnnotatedHandlerInspector <C> CreateInspector <C>(
IParameterResolverFactory parameterResolverFactory,
IHandlerDefinition handlerDefinition,
Dictionary <Type, AnnotatedHandlerInspector <T> > registry)
{
return(CreateInspector <C>(
typeof(C),
parameterResolverFactory,
handlerDefinition,
registry
));
}
public AnnotationEventHandlerAdapter(
object annotatedEventListener,
IParameterResolverFactory parameterResolverFactory,
IHandlerDefinition handlerDefinition
)
{
_annotatedEventListener = annotatedEventListener;
_listenerType = annotatedEventListener.GetType();
_inspector = AnnotatedHandlerInspector <object> .InspectType(annotatedEventListener.GetType(),
parameterResolverFactory,
handlerDefinition);
}
public NATHandlerController(IHandlerDefinition hbDefinition, IEnvironment env)
: base(hbDefinition, env, null)
{
StandardOutPort.Name = "Internal NAT Out Port";
StandardOutPort.Description = "All frames send out this port are translated to internal addresses to provide consistend addressing. This port is meant to be linked with traffic handlers doing analysis and modification.";
StandardOutPort.Abbreviation = "itx";
InternalOutPort = StandardOutPort;
StandardInPort.Name = "Internal NAT In Port";
StandardInPort.Description = "Traffic pushed into this port will be translated to external addresses and pushed out to the External Output Port. This port is meant to be linked with traffic handlers doing analysis and modification.";
StandardInPort.Abbreviation = "irx";
InternalInPort = StandardInPort;
}
public static AnnotatedHandlerInspector <T> InspectType(
Type handlerType,
IParameterResolverFactory parameterResolverFactory,
IHandlerDefinition handlerDefinition
)
{
return(CreateInspector(
handlerType,
parameterResolverFactory,
handlerDefinition,
new Dictionary <Type, AnnotatedHandlerInspector <T> >()
));
}
private AnnotatedHandlerInspector(Type inspectedType,
List <AnnotatedHandlerInspector <T> > superClassInspectors,
IParameterResolverFactory parameterResolverFactory,
IHandlerDefinition handlerDefinition,
Dictionary <Type, AnnotatedHandlerInspector <T> > registry)
{
this.inspectedType = inspectedType;
this.parameterResolverFactory = parameterResolverFactory;
this.registry = registry;
this.superClassInspectors = new List <AnnotatedHandlerInspector <T> >(superClassInspectors);
this.handlers = new List <IMessageHandlingMember <T> >();
this.handlerDefinition = handlerDefinition;
}
private static AnnotatedHandlerInspector <C> CreateInspector <C>(
Type inspectedType,
IParameterResolverFactory parameterResolverFactory,
IHandlerDefinition handlerDefinition,
Dictionary <Type, AnnotatedHandlerInspector <T> > registry)
{
if (!registry.ContainsKey(inspectedType))
{
registry.Add(inspectedType,
AnnotatedHandlerInspector.Initialize <C>(
parameterResolverFactory,
handlerDefinition,
registry)
);
}
//noinspection unchecked
return(registry[inspectedType]);
}
private static AnnotatedHandlerInspector <C> Initialize <C>(
IParameterResolverFactory parameterResolverFactory,
IHandlerDefinition handlerDefinition,
Dictionary <Type, AnnotatedHandlerInspector <C> > registry)
{
var inspectedType = typeof(C);
List <AnnotatedHandlerInspector <T> > parents = new List <AnnotatedHandlerInspector <T> >();
foreach (Type iFace in inspectedType.GetInterfaces())
{
//noinspection unchecked
parents.Add(
CreateInspector(
iFace,
parameterResolverFactory,
handlerDefinition,
registry
)
);
}
if (inspectedType.BaseType != null && typeof(object) != inspectedType.BaseType)
{
parents.Add(
CreateInspector(inspectedType.BaseType,
parameterResolverFactory,
handlerDefinition,
registry)
);
}
AnnotatedHandlerInspector <T> inspector = new AnnotatedHandlerInspector <T>(
inspectedType,
parents,
parameterResolverFactory,
handlerDefinition,
registry
);
inspector.InitializeMessageHandlers(parameterResolverFactory, handlerDefinition);
return(inspector);
}
private void InitializeMessageHandlers(
IParameterResolverFactory parameterResolverFactory,
IHandlerDefinition handlerDefinition
)
{
foreach (MethodInfo method in inspectedType.GetMethods())
{
var messageHandlingMember =
handlerDefinition.CreateHandler <T>(inspectedType, method, parameterResolverFactory);
this.RegisterHandler(messageHandlingMember);
}
foreach (ConstructorInfo constructor in inspectedType.GetConstructors())
{
this.RegisterHandler(
handlerDefinition.CreateHandler(inspectedType, constructor, parameterResolverFactory)
);
}
superClassInspectors.ForEach(sci => handlers.AddRange(sci.handlers));
handlers.Sort(HandlerComparator.instance());
}
public DHCPServerController(IHandlerDefinition hbDefinition, IEnvironment env)
: base(hbDefinition, env, null)
{
}
protected AbstractRepository(IParameterResolverFactory parameterResolverFactory, IHandlerDefinition handlerDefinition)
: this(AnnotatedAggregateMetaModelFactory.InspectAggregate(typeof(T),
NotNull(parameterResolverFactory, () => "parameterResolverFactory may not be null"),
NotNull(handlerDefinition, () => "handler definition may not be null")))
{
}
public EthernetInterfaceController(WinPcapInterface wpcInt, IHandlerDefinition hbDefinition, IEnvironment env)
: base(hbDefinition, env, wpcInt)
{
this.wpcInt = wpcInt;
}
public HTTPStreamModifierController(IHandlerDefinition hbDefinition, IEnvironment env)
: base(hbDefinition, env, null)
{
}
private static AnnotatedHandlerInspector Initialize(Type inspectedType, IParameterResolverFactory parameterResolverFactory, IHandlerDefinition handlerDefinition, Dictionary <Type, AnnotatedHandlerInspector> registry)
{
var parents = new List <AnnotatedHandlerInspector>();
foreach (var iface in inspectedType.GetInterfaces())
{
parents.Add(CreateInspector(iface, parameterResolverFactory, handlerDefinition, registry));
}
if (inspectedType.BaseType != null && typeof(object) != inspectedType.BaseType)
{
parents.Add(CreateInspector(inspectedType.BaseType, parameterResolverFactory, handlerDefinition, registry));
}
var inspector = new AnnotatedHandlerInspector(inspectedType, parents, parameterResolverFactory, handlerDefinition, registry);
inspector.InitializeMessageHandlers(parameterResolverFactory, handlerDefinition);
return(inspector);
}
public TrafficSplitterController(IHandlerDefinition hbDefinition, IEnvironment env)
: base(hbDefinition, env, null)
{
}
public WANEmulatorController(IHandlerDefinition hbDefinition, IEnvironment env)
: base(hbDefinition, env, null)
{
}
public static IAggregateModel InspectAggregate(Type aggregateType, IParameterResolverFactory parameterResolverFactory, IHandlerDefinition handlerDefinition)
{
return(new AnnotatedAggregateMetaModelFactory(parameterResolverFactory, handlerDefinition).CreateModel(aggregateType));
}
public AnnotatedAggregateMetaModelFactory(IParameterResolverFactory parameterResolverFactory, IHandlerDefinition handlerDefinition)
{
_parameterResolverFactory = parameterResolverFactory;
_handlerDefinition = handlerDefinition;
}
public NetLabPluginController(IHandlerDefinition hdBaseDefinition, INetLabEnvironment iEnvironment) : base(hdBaseDefinition, iEnvironment, null)
{
}
public APRAttackController(IHandlerDefinition hbDefinition, IEnvironment env) : base(hbDefinition, env, null)
{
}
public NetMapController(IHandlerDefinition hbDefinition, IEnvironment env)
: base(hbDefinition, env, null)
{
}
public PluginController(IHandlerDefinition hbDefinition, IEnvironment env)
: base(hbDefinition, env, null) //Simply call the base constructor.
{
}
public SpeedMeterController(IHandlerDefinition hbDefinition, IEnvironment env)
: base(hbDefinition, env, null)
{
}
private static AnnotatedHandlerInspector CreateInspector(Type inspectedType, IParameterResolverFactory parameterResolverFactory, IHandlerDefinition handlerDefinition, Dictionary <Type, AnnotatedHandlerInspector> registry)
{
if (!registry.ContainsKey(inspectedType))
{
registry[inspectedType] = AnnotatedHandlerInspector.Initialize(inspectedType, parameterResolverFactory, handlerDefinition, registry);
}
return(registry[inspectedType]);
}
public DNSOTFSpooferController(IHandlerDefinition hbDefinition, IEnvironment env)
: base(hbDefinition, env, null)
{
}
public HTTPMonitorController(IHandlerDefinition hbDefinition, IEnvironment env)
: base(hbDefinition, env, null)
{
}
private void InitializeMessageHandlers(IParameterResolverFactory parameterResolverFactory, IHandlerDefinition handlerDefinition)
{
foreach (var method in _inspectedType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
_handlerDefinition.CreateHandler(_inspectedType, method, parameterResolverFactory)
.IfPresent(RegisterHandler);
}
foreach (var constructor in _inspectedType.GetConstructors())
{
_handlerDefinition.CreateHandler(_inspectedType, constructor, parameterResolverFactory)
.IfPresent(RegisterHandler);
}
_superClassInspectors.ForEach(sci => Handlers.AddRange(sci.Handlers));
Handlers.Sort(HandlerComparator.Instance);
}
