/// <summary>
/// Restart module with the given name.
/// </summary>
/// <param name="moduleName"> Module name. </param>
/// <param name="ct"> Cancellation token. </param>
public async Task <MethodResultModel> RestartModule(
string moduleName,
CancellationToken ct)
{
var payload = new Dictionary <string, string> {
{ "schemaVersion", "1.0" },
{ "id", moduleName },
};
var parameters = new MethodParameterModel {
Name = "RestartModule",
JsonPayload = _serializer.SerializeToString(payload)
};
var moduleRestartResponse = await TestHelper.CallMethodAsync(
_iotHubClient,
_iotHubPublisherDeviceName,
"$edgeAgent",
parameters,
_context,
ct
).ConfigureAwait(false);
return(moduleRestartResponse);
}
/// <inheritdoc/>
public async Task <MethodResultModel> CallMethodAsync(string deviceId, string moduleId,
MethodParameterModel parameters, CancellationToken ct)
{
if (string.IsNullOrEmpty(deviceId))
{
throw new ArgumentNullException(nameof(deviceId));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (string.IsNullOrEmpty(parameters.Name))
{
throw new ArgumentNullException(nameof(parameters.Name));
}
var request = NewRequest(
$"/twins/{ToResourceId(deviceId, moduleId)}/methods");
request.SetContent(new {
methodName = parameters.Name,
// TODO: Add timeouts...
// responseTimeoutInSeconds = ...
payload = JToken.Parse(parameters.JsonPayload)
});
var response = await _httpClient.PostAsync(request, ct);
response.Validate();
dynamic result = JToken.Parse(response.GetContentAsString());
return(new MethodResultModel {
JsonPayload = ((JToken)result.payload).ToString(),
Status = result.status
});
}
/// <inheritdoc/>
public async Task <MethodResultModel> CallMethodAsync(string deviceId, string moduleId,
MethodParameterModel parameters, CancellationToken ct)
{
if (string.IsNullOrEmpty(deviceId))
{
throw new ArgumentNullException(nameof(deviceId));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (string.IsNullOrEmpty(parameters.Name))
{
throw new ArgumentNullException(nameof(parameters.Name));
}
var request = NewRequest(
$"/twins/{ToResourceId(deviceId, moduleId)}/methods");
_serializer.SerializeToRequest(request, new {
methodName = parameters.Name,
// TODO: Add timeouts...
// responseTimeoutInSeconds = ...
payload = _serializer.Parse(parameters.JsonPayload)
});
var response = await _httpClient.PostAsync(request, ct);
response.Validate();
var result = _serializer.ParseResponse(response);
return(new MethodResultModel {
JsonPayload = _serializer.SerializeToString(result["payload"]),
Status = (int)result["status"]
});
}
/// <summary>
/// Perform direct method call.
/// </summary>
/// <param name="parameters"> Direct method parameters. </param>
/// <param name="ct"> Cancellation token. </param>
/// <returns></returns>
public async Task <MethodResultModel> CallMethodAsync(
MethodParameterModel parameters,
CancellationToken ct
)
{
return(await TestHelper.CallMethodAsync(
_iotHubClient,
_iotHubPublisherDeviceName,
_iotHubPublisherModuleName,
parameters,
_context,
ct
).ConfigureAwait(false));
}
/// <inheritdoc/>
public async Task <MethodResultModel> CallMethodAsync(string deviceId, string moduleId,
MethodParameterModel parameters, CancellationToken ct)
{
try {
var methodInfo = new CloudToDeviceMethod(parameters.Name);
methodInfo.SetPayloadJson(parameters.JsonPayload);
var result = await(string.IsNullOrEmpty(moduleId) ?
_client.InvokeDeviceMethodAsync(deviceId, methodInfo, ct) :
_client.InvokeDeviceMethodAsync(deviceId, moduleId, methodInfo, ct));
return(new MethodResultModel {
JsonPayload = result.GetPayloadAsJson(),
Status = result.Status
});
}
catch (Exception e) {
_logger.Verbose(e, "Call method failed ");
throw e.Rethrow();
}
}
/// <summary>
/// Call a direct method
/// </summary>
/// <param name="serviceClient">Device service client</param>
/// <param name="deviceId">Device Id</param>
/// <param name="moduleId">Module Id</param>
/// <param name="parameters">Method parameter </param>
/// <param name="context">Shared Context for E2E testing Industrial IoT Platform</param>
/// <param name="ct">Cancellation token</param>
public static async Task <MethodResultModel> CallMethodAsync(ServiceClient serviceClient, string deviceId, string moduleId,
MethodParameterModel parameters, IIoTPlatformTestContext context, CancellationToken ct)
{
try {
var methodInfo = new CloudToDeviceMethod(parameters.Name);
methodInfo.SetPayloadJson(parameters.JsonPayload);
var result = await(string.IsNullOrEmpty(moduleId) ?
serviceClient.InvokeDeviceMethodAsync(deviceId, methodInfo, ct) :
serviceClient.InvokeDeviceMethodAsync(deviceId, moduleId, methodInfo, ct));
return(new MethodResultModel {
JsonPayload = result.GetPayloadAsJson(),
Status = result.Status
});
}
catch (Exception e) {
PrettyPrintException(e, context.OutputHelper);
return(null);
}
}
/// <summary>
/// Call device method on twin
/// </summary>
/// <param name="service"></param>
/// <param name="deviceId"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public static Task <MethodResultModel> CallMethodAsync(this IIoTHubTwinServices service,
string deviceId, MethodParameterModel parameters) =>
service.CallMethodAsync(deviceId, null, parameters);
/// <summary>
/// Call device method on twin
/// </summary>
/// <param name="service"></param>
/// <param name="deviceId"></param>
/// <param name="parameters"></param>
/// <param name="ct"></param>
/// <returns></returns>
public static Task <MethodResultModel> CallMethodAsync(this IIoTHubTwinServices service,
string deviceId, MethodParameterModel parameters, CancellationToken ct = default)
{
return(service.CallMethodAsync(deviceId, null, parameters, ct));
}
/// <inheritdoc/>
public Task <MethodResultModel> CallMethodAsync(string deviceId, string moduleId,
MethodParameterModel parameters)
{
throw new NotSupportedException();
}
