private void Logic_Client_RetryRequestInternal(Action <PrtgClient> action, bool isAsync)
{
var initialThread = Thread.CurrentThread.ManagedThreadId;
Impersonator.ExecuteAction(() =>
{
var retriesMade = 0;
var retriesToMake = 3;
var coreService = new ServiceController("PRTGCoreService", Settings.Server);
var localClient = new PrtgClient(Settings.ServerWithProto, Settings.UserName, Settings.Password);
localClient.RetryRequest += (sender, args) =>
{
Logger.LogTestDetail($"Handling retry {retriesMade + 1}");
if (!isAsync)
{
AssertEx.AreEqual(initialThread, Thread.CurrentThread.ManagedThreadId, "Event was not handled on initial thread");
}
retriesMade++;
};
localClient.RetryCount = retriesToMake;
Logger.LogTestDetail("Stopping PRTG Service");
coreService.Stop();
coreService.WaitForStatus(ServiceControllerStatus.Stopped);
try
{
action(localClient);
}
catch (AggregateException ex)
{
if (ex.InnerException != null && ex.InnerException.GetType() == typeof(AssertFailedException))
{
throw ex.InnerException;
}
}
catch (WebException)
{
}
finally
{
Logger.LogTestDetail("Starting PRTG Service");
coreService.Start();
coreService.WaitForStatus(ServiceControllerStatus.Running);
Logger.LogTestDetail("Sleeping for 20 seconds");
Thread.Sleep(20000);
Logger.LogTestDetail("Refreshing and sleeping for 20 seconds");
localClient.RefreshObject(Settings.Device);
Thread.Sleep(20000);
}
AssertEx.AreEqual(retriesToMake, retriesMade, "An incorrect number of retries were made.");
});
}
public void Logic_Client_ConnectWithHttps()
{
var server = $"https://{Settings.Server}";
try
{
var client = new PrtgClient(server, Settings.Username, Settings.Password);
}
catch (WebException ex)
{
if (ex.InnerException != null)
{
if (ex.InnerException.Message.StartsWith("No connection could be made because the target machine actively refused it"))
{
if (Settings.Protocol != HttpProtocol.HTTP)
{
Assert.Fail($"{ex.Message}. This may indicate your PRTG Server does not accept HTTPS or that your certificate is invalid. If your server does not accept HTTPS please change your Protocol in Settings.cs");
}
}
else
{
throw;
}
}
else
{
throw;
}
}
}
private static SensorQueryTarget GetQueryTarget(PrtgClient client, int deviceId, string sensorType, SensorQueryTarget queryTarget)
{
if (queryTarget != null && queryTarget.Value.Contains("*"))
{
var allTypes = client.GetSensorTypes(deviceId);
var desiredType = allTypes.FirstOrDefault(t => string.Equals(t.Id, sensorType, StringComparison.OrdinalIgnoreCase));
if (desiredType != null)
{
if (desiredType.QueryTargets == null)
{
return(queryTarget); //Type does not support query targets; leave it to internal engine to throw exception
}
var wildcard = new WildcardPattern(queryTarget.Value, WildcardOptions.IgnoreCase);
var candidates = desiredType.QueryTargets.Where(a => wildcard.IsMatch(a.Value)).ToList();
if (candidates.Count == 1)
{
return(candidates.Single());
}
else if (candidates.Count > 1)
{
throw new InvalidOperationException($"Query target wildcard '{queryTarget}' is ambiguous between the following parameters: {candidates.ToQuotedList()}. Please specify a more specific identifier.");
}
else
{
throw new InvalidOperationException($"Could not find a query target matching the wildcard expression '{queryTarget}'. Please specify one of the following parameters: {desiredType.QueryTargets.ToQuotedList()}.");
}
}
}
return(queryTarget);
}
public async Task Logic_Client_ConnectWithHttps_Async()
{
var server = $"https://{Settings.Server}";
var localClient = new PrtgClient(server, Settings.UserName, client.PassHash, AuthMode.PassHash);
//Get the method
var engine = localClient.GetInternalProperty("RequestEngine");
var flags = BindingFlags.NonPublic | BindingFlags.Instance;
var methods = engine.GetType().GetMethods(flags).Where(m => m.Name == "ExecuteRequestAsync").ToList();
var method = methods.First(m => m.GetParameters().Any(p => p.ParameterType.Name == "IJsonParameters"));
//Construct the parameters
var parameters = PrtgAPIHelpers.GetPassHashParameters(Settings.Password);
try
{
await(Task <string>) method.Invoke(engine, new object[] { parameters, null });
}
catch (WebException ex)
{
if (ex.Message != "Server rejected HTTPS connection on port 443. Please confirm expected server protocol and port, PRTG Core Service is running and that any SSL certificate is trusted")
{
throw;
}
}
}
internal static IEnumerable <PrtgObject> LiftObjects(PrtgClient client, IEnumerable <PrtgObject> objects)
{
var grouped = objects.GroupBy(d => d.Type);
foreach (var group in grouped)
{
switch (group.Key.Value)
{
case ObjectType.Sensor:
foreach (var s in Sensors(client, group))
{
yield return(s);
}
break;
case ObjectType.Device:
foreach (var d in Devices(client, group))
{
yield return(d);
}
break;
case ObjectType.Group:
foreach (var g in Groups(client, group))
{
yield return(g);
}
break;
case ObjectType.Probe:
foreach (var p in Probes(client, group))
{
yield return(p);
}
break;
case ObjectType.Notification:
foreach (var n in Notifications(client, group))
{
yield return(n);
}
break;
case ObjectType.Schedule:
foreach (var s in Schedules(client, group))
{
yield return(s);
}
break;
default:
foreach (var g in group)
{
yield return(g);
}
break;
}
}
}
private void ExecuteFailedRequest(HttpStatusCode statusCode, string xml, string address, string expectedError)
{
var response = new FailedRequestResponse(statusCode, xml, address);
var client = new PrtgClient("prtg.example.com", "username", "1234567890", AuthMode.PassHash, new MockWebClient(response));
AssertEx.Throws <PrtgRequestException>(() => client.GetSensors(), $"PRTG was unable to complete the request. The server responded with the following error: {expectedError}");
}
public static PrtgClient Initialize_Client(IWebResponse response)
{
var webClient = new MockWebClient(response);
var client = new PrtgClient("prtg.example.com", "username", "12345678", AuthMode.PassHash, webClient);
return(client);
}
public void Logic_Client_NullCredentials()
{
var server = $"http://{Settings.Server}";
string username = null;
string password = null;
var client = new PrtgClient(server, username, password);
}
public void PrtgClient_Constructor_RetrievesPassHash()
{
var webClient = new MockWebClient(new PassHashResponse());
var client = new PrtgClient("prtg.example.com", "username", "password", AuthMode.Password, webClient);
Assert.IsTrue(client.PassHash == "12345678");
}
public void SensorTotals_AllFields_HaveValues()
{
var webClient = new MockWebClient(new SensorTotalsResponse(new Items.SensorTotalsItem()));
var client = new PrtgClient("prtg.example.com", "username", "12345678", AuthMode.PassHash, webClient);
var result = client.GetSensorTotals();
Assert2.AllPropertiesAreNotDefault(result);
}
private PrtgClient GetRestartProbeClient()
{
var standardClient = Initialize_Client(new BasicResponse(string.Empty));
var webClient = new MockWebClient(new RestartProbeResponse());
var customClient = new PrtgClient(standardClient.Server, standardClient.UserName, standardClient.PassHash, AuthMode.PassHash, webClient);
return(customClient);
}
public async Task AdminTool_RestartCore_CanWaitAsync()
{
var standardClient = Initialize_Client(new BasicResponse(string.Empty));
var webClient = new MockWebClient(new RestartPrtgCoreResponse());
var customClient = new PrtgClient(standardClient.Server, standardClient.UserName, standardClient.PassHash, AuthMode.PassHash, webClient);
await customClient.RestartCoreAsync(true);
}
protected NotificationAction GetNotificationAction()
{
var webClient = new MockWebClient(new NotificationActionResponse(new[] { new NotificationActionItem() }));
var client = new PrtgClient("prtg.example.com", "username", "12345678", AuthMode.PassHash, webClient);
return(client.GetNotificationActions().First());
}
private PrtgClient GetCustomClient(MethodInfo method, PrtgClient defaultClient)
{
if (method.Name == "GetNotificationTriggers" || method.Name == "GetNotificationTriggersAsync")
{
return(BaseTest.Initialize_Client(new NotificationTriggerResponse(NotificationTriggerItem.StateTrigger())));
}
return(defaultClient);
}
/// <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);
}
internal TreeBuilder(PrtgClient client, FlagEnum <TreeParseOption>?options, ITreeProgressCallback progressCallback, FlagEnum <TreeRequestType> requestType, CancellationToken token)
{
ProgressManager = new TreeProgressManager(progressCallback);
ObjectManager = new ObjectManager(client);
Token = token;
Options = options ?? TreeParseOption.Common;
RequestType = requestType;
this.client = client;
}
internal CachedObjectManager(PrtgClient client, List <Sensor> sensors, List <Device> devices, List <Group> groups, List <Probe> probes)
{
Sensor = new CachedSensorFactory(client, sensors);
Device = new CachedDeviceFactory(client, devices);
Group = new CachedGroupFactory(client, groups);
Probe = new CachedProbeFactory(client, probes);
Trigger = new TriggerFactory(client);
Property = new PropertyFactory(client);
}
public void Object_DeserializesSchedule()
{
var webClient = new MockWebClient(new SensorSettingsResponse());
var client = new PrtgClient("server", "username", "1234567890", AuthMode.PassHash, webClient);
var properties = client.GetSensorProperties(1001);
Assert.AreEqual("Weekdays Nights (17:00 - 9:00) [GMT+0800]", properties.Schedule.ToString(), "Schedule was not correct");
}
internal static bool IsEnglish(PrtgClient client, bool defaultValue = true)
{
string language;
if (client.GetObjectPropertiesRaw(810).TryGetValue("languagefile", out language))
{
return(language == "english.lng");
}
return(defaultValue);
}
public NewSensorDynamicParameterContainer(NewSensor newSensorCmdlet, PrtgClient client)
{
InitializeParameterCategories();
activeSensorType = new Lazy <NewSensorDynamicParameterCategory>(() => parameterCategories.Single(c => c.HasParameterSet(newSensorCmdlet)));
this.newSensorCmdlet = newSensorCmdlet;
this.client = client;
Parameters = GetDynamicParameters();
}
internal static SensorMultiQueryTargetParameters GetQueryTargetParameters(PrtgClient client, int deviceId, string sensorType, SensorQueryTarget queryTarget, Hashtable queryParametersRaw)
{
queryTarget = GetQueryTarget(client, deviceId, sensorType, queryTarget);
var queryParameters = GetQueryParameters(queryParametersRaw);
if (queryTarget != null || queryParameters != null)
{
return(new SensorMultiQueryTargetParameters(queryTarget, queryParameters));
}
return(null);
}
private PrtgClient GetTimeoutClient()
{
var localClient = new PrtgClient(Settings.ServerWithProto, Settings.UserName, Settings.Password);
var engine = localClient.GetInternalProperty("RequestEngine");
var webInterface = engine.GetInternalField("webClient");
var httpClient = new HttpClient
{
Timeout = new TimeSpan(0, 0, 0, 0, 1)
};
webInterface.GetType().GetField("asyncClient", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(webInterface, httpClient);
return(localClient);
}
public void Logic_Client_ConnectWithHttps()
{
var server = $"https://{Settings.Server}";
try
{
var localClient = new PrtgClient(server, Settings.UserName, Settings.Password);
}
catch (WebException ex)
{
if (ex.Message != "Server rejected HTTPS connection on port 443. Please confirm expected server protocol and port, PRTG Core Service is running and that any SSL certificate is trusted")
{
throw;
}
}
}
public EventValidator(PrtgClient client, string[] list)
{
this.list = list;
client.LogVerbose += (s, e) =>
{
var message = e.Message;
if (message.StartsWith("Synchronously") || message.StartsWith("Asynchronously"))
{
message = Regex.Replace(e.Message, "(.+ request )(.+)", "$2");
}
Assert.AreEqual(Get(message), message);
};
}
public void Logic_Client_InvalidServer()
{
string server = "a";
try
{
var client = new PrtgClient(server, Settings.UserName, Settings.Password);
}
catch (WebException ex)
{
if (ex.Message != $"The remote name could not be resolved: '{server}'")
{
AssertEx.Fail($"Request did not fail with expected error message: {ex.Message}");
}
}
}
public void AdminTool_RestartProbe_CanWait()
{
var standardClient = Initialize_Client(new BasicResponse(string.Empty));
var webClient = new MockWebClient(new RestartProbeResponse());
var customClient = new PrtgClient(standardClient.Server, standardClient.UserName, standardClient.PassHash, AuthMode.PassHash, webClient);
var count = 0;
customClient.RestartProbe(null, true, probes =>
{
count += probes.Count;
return(false);
});
Assert.AreEqual(2, count, "Callback was not called expected number of times");
}
private static PrtgClient Initialize()
{
if (Int32.TryParse(PrtgServerUsesHttp, out var prtgServerUsesHttp))
{
Int32.TryParse(PrtgServerUsesHttp, out prtgServerUsesHttp);
}
else
{
prtgServerUsesHttp = 1;
_writeLog.Append(DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.ffff") + ": " + "Can't convert argument PrtgServerUsesHttp from MonitoringTelegramBot.exe.config to integer. Using default value = 1 (true). Please check the application configuration file.");
}
string serverAddress = PrtgServerApiAddress;
if (prtgServerUsesHttp == 1)
{
serverAddress = "http://" + PrtgServerApiAddress;
}
var prtgClient = new PrtgClient(serverAddress, PrtgServerApiUserName, PrtgServerApiPasshash, AuthMode.PassHash);
if (Int32.TryParse(PrtgServerApiConnectionTimeout, out var prtgServerApiConnectionTimeout))
{
Int32.TryParse(PrtgServerApiConnectionTimeout, out prtgServerApiConnectionTimeout);
}
else
{
prtgServerApiConnectionTimeout = 5;
_writeLog.Append(DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.ffff") + ": " + "Can't convert argument PrtgServerApiConnectionTimeout from MonitoringTelegramBot.exe.config to integer. Using default value = 5 seconds. Please check the application configuration file.");
}
if (Int32.TryParse(PrtgServerApiConnectionRetryCount, out var prtgServerApiConnectionRetryCount))
{
Int32.TryParse(PrtgServerApiConnectionRetryCount, out prtgServerApiConnectionRetryCount);
}
else
{
prtgServerApiConnectionRetryCount = 2;
_writeLog.Append(DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.ffff") + ": " + "Can't convert argument PrtgServerApiConnectionRetryCount from MonitoringTelegramBot.exe.config to integer. Using default value = 2. Please check the application configuration file.");
}
prtgClient.RetryDelay = prtgServerApiConnectionTimeout;
prtgClient.RetryCount = prtgServerApiConnectionRetryCount;
return(prtgClient);
}
public Message GetStatus()
{
Message message = new Message();
_writeLog.Append(DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.ffff") + ": " + "Starting initialization the PRTG API Connector.");
_writeLog.Append(DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.ffff") + ": " + "Using the following PRTG API Server to connect: " + PrtgServerApiAddress);
_writeLog.Append(DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.ffff") + ": " + "Using the following Username to connect: " + PrtgServerApiUserName);
_writeLog.Append(DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.ffff") + ": " + "Using the following Passhash to connect: " + PrtgServerApiPasshash);
PrtgClient prtgClient = Initialize();
ServerStatus serverStatus;
try
{
serverStatus = prtgClient.GetStatus();
}
catch (Exception e)
{
_writeLog.Append(DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.ffff") + ": " + " Error to connect PRTG Server");
_writeLog.Append(DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.ffff") + ": " + e);
message.Append("Error to connect to PRTG Server " + PrtgServerApiAddress);
return(message);
}
message.Append("Healthy Sensors: " + serverStatus.UpSensors);
message.Append("Unhealthy Sensors: " + serverStatus.Alarms);
message.Append("Warning Sensors: " + serverStatus.WarningSensors);
message.Append("Paused Sensors: " + serverStatus.PausedSensors);
message.Append("Partial Alarams Sensors: " + serverStatus.PartialAlarms);
message.Append("Unknown Sensors: " + serverStatus.UnknownSensors);
message.Append("Unusual Sensors: " + serverStatus.UnusualSensors);
_writeLog.Append(DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.ffff") + ": PRTG Server Returned:\n");
if (message.GetMessages() != null)
{
foreach (string text in message.GetMessages())
{
_writeLog.Append(text);
}
}
return(message);
}
public void PrtgClient_SplitsRequests_BatchingOver1500Items()
{
var range = Enumerable.Range(1, 2000).ToArray();
var server = "prtg.example.com";
var username = "******";
var passhash = "1234567890";
string[] urls =
{
$"https://{server}/api/pause.htm?id={string.Join(",", Enumerable.Range(1, 1500))}&action=0&username={username}&passhash={passhash}",
$"https://{server}/api/pause.htm?id={string.Join(",", Enumerable.Range(1501, 500))}&action=0&username={username}&passhash={passhash}"
};
var client = new PrtgClient(server, username, passhash, AuthMode.PassHash, new MockWebClient(new AddressValidatorResponse(urls, true)));
client.PauseObject(range);
}
public void Serializer_ThrowsInvalidEnum()
{
var webClient = new MockWebClient(new SensorResponse(new SensorItem(status: "banana", statusRaw: "8765")));
var client = new PrtgClient("prtg.example.com", "username", "password", AuthMode.PassHash, webClient);
try
{
client.GetSensors();
}
catch (Exception ex)
{
if (ex.Message != "Could not deserialize value '8765' as it is not a valid member of type 'PrtgAPI.Status'. Could not process XML '<status>banana</status><status_raw>8765</status_raw><message><div class=\"status\">OK<div class=\"moreicon\"></div></div></message>'")
{
throw;
}
}
}
