/// <summary>
/// Initializes a new instance of the <see cref="ObjectManager"/> class.
/// </summary>
/// <param name="client">The client to use for executing API requests.</param>
internal ObjectManager(PrtgClient client)
{
Sensor = new SensorFactory(client);
Device = new DeviceFactory(client);
Group = new GroupFactory(client);
Probe = new ProbeFactory(client);
Trigger = new TriggerFactory(client);
Property = new PropertyFactory(client);
}
public IAgentHost Build()
{
AgentId.VerifyNotNull(nameof(AgentId));
ProbeFactory.VerifyNotNull(nameof(ProbeFactory));
TraceContainer.VerifyNotNull(nameof(TraceContainer));
LoggerFactory.VerifyNotNull(nameof(LoggerFactory));
var monitoringJobs = Targets
.VerifyNotNull(nameof(Targets))
.Select(x => (Target: x, Probe: ProbeFactory.Create(x, AgentId, TraceContainer)))
.Select(x => new MonitoringJob(x.Target, x.Probe, LoggerFactory.CreateLogger <MonitoringJob>()))
.ToArray();
return(new AgentHost(monitoringJobs, LoggerFactory.CreateLogger <AgentHost>()));
}
private static KeyValuePair <Regex, Action <ILexerArg <T> > > ResolveHandler(
AmbiguityResolverEnum ambiguityResolverEnum, string buffer, char next, T lastToken,
// ReSharper disable once ParameterTypeCanBeEnumerable.Local
List <KeyValuePair <Regex, Action <ILexerArg <T> > > > handlers)
{
switch (ambiguityResolverEnum)
{
case AmbiguityResolverEnum.FirstMatch:
return(handlers.First());
case AmbiguityResolverEnum.LastMatch:
return(handlers.Last());
case AmbiguityResolverEnum.LongestMatch:
var handlerAny = handlers
.Select(x => new
{
Handler = x,
Factory = ProbeFactory.New <string>()
})
.Select(x => new
{
// ReSharper disable once AccessToModifiedClosure
x.Factory, x.Handler, Arg = new LexerArg <T>(buffer, next, lastToken,
// Test should not be able to stop the parser
() => { },
(a, b) => x.Factory.Instance.SetValue(a),
_ => { },
_ => { }
)
})
.Select(x =>
{
var result = new
{
x.Factory,
x.Handler,
x.Arg,
Probe = x.Factory.Build()
};
result.Handler.Value(x.Arg);
return(result);
})
.Select(x =>
{
var result = new
{
x.Probe,
x.Handler
};
x.Probe.Trigger();
return(result);
})
.Where(x => x.Probe.Resolved)
.OrderBy(x => x.Probe.Value.Length)
.LastOrDefault();
return(handlerAny?.Handler ?? ResolveHandler(AmbiguityResolverEnum.FirstMatch, buffer, next,
lastToken, handlers));
default:
throw new ArgumentOutOfRangeException();
}
}
