/// <summary>
/// Alarm activates, deactivates, and queries alarms regarding cluster health in async
/// </summary>
/// <param name="request">Alarm request</param>
/// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
/// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
/// <param name="cancellationToken">An optional token for canceling the call.</param>
/// <returns>Alarm Response</returns>
public async Task <AlarmResponse> AlarmAsync(AlarmRequest request, Grpc.Core.Metadata headers = null,
DateTime?deadline = null,
CancellationToken cancellationToken = default)
{
return(await CallEtcdAsync(async (connection) => await connection._maintenanceClient
.AlarmAsync(request, headers, deadline, cancellationToken)).ConfigureAwait(false));
}
/// <summary>
/// Alarm activates, deactivates, and queries alarms regarding cluster health in async
/// </summary>
/// <param name="request">Alarm request</param>
/// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
/// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
/// <param name="cancellationToken">An optional token for canceling the call.</param>
/// <returns>Alarm Response</returns>
public async Task <AlarmResponse> AlarmAsync(AlarmRequest request, Grpc.Core.Metadata headers = null,
DateTime?deadline = null,
CancellationToken cancellationToken = default)
{
AlarmResponse response = new AlarmResponse();
bool success = false;
int retryCount = 0;
while (!success)
{
try
{
response = await _balancer.GetConnection().maintenanceClient
.AlarmAsync(request, headers, deadline, cancellationToken);
success = true;
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.Unavailable)
{
retryCount++;
if (retryCount >= _balancer._numNodes)
{
throw;
}
}
}
return(response);
}
/// <summary>
/// Alarm activates, deactivates, and queries alarms regarding cluster health in async
/// </summary>
/// <param name="request">Alarm request</param>
/// <returns>Alarm Response</returns>
public async Task <AlarmResponse> AlarmAsync(AlarmRequest request, Metadata headers = null)
{
AlarmResponse response = new AlarmResponse();
bool success = false;
int retryCount = 0;
while (!success)
{
try
{
response = await _balancer.GetConnection().maintenanceClient.AlarmAsync(request, headers);
success = true;
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.Unavailable)
{
retryCount++;
if (retryCount >= _balancer._numNodes)
{
throw ex;
}
}
}
return(response);
}
/// <summary>
/// Alarm activates, deactivates, and queries alarms regarding cluster health in async
/// </summary>
/// <param name="request">Alarm request</param>
/// <returns>Alarm Response</returns>
public async Task <AlarmResponse> AlarmAsync(AlarmRequest request, Metadata headers = null)
{
AlarmResponse response = new AlarmResponse();
response = await _balancer.GetConnection().maintenanceClient.AlarmAsync(request, headers);
return(response);
}
/// <summary>
/// Alarm activates, deactivates, and queries alarms regarding cluster health
/// </summary>
/// <param name="request">Alarm request</param>
/// <returns>Alarm Response</returns>
public AlarmResponse Alarm(AlarmRequest request, Metadata headers = null)
{
AlarmResponse response = new AlarmResponse();
response = _balancer.GetConnection().maintenanceClient.Alarm(request, headers);
return(response);
}
public async Task <bool> SetAlarmModeAsync(Guid paritionUuid, string pinCode, Enums.AlarmArmMode newStatus, string secureSessionId = null,
bool raiseExceptionWhenNotSuccesful = true)
{
if (secureSessionId == null)
{
var session = await InitializeSecuritySessionAsync();
if (!session.Success)
{
throw new Exceptions.CannotEstablishSecuritySessionException(session.Error);
}
var pinLoginResponse = await LoginAlarmWithPinAsync(session.Response.SecureSessionId,
session.Response.Salt,
session.Response.Nonce, pinCode);
if (!pinLoginResponse.Success || !pinLoginResponse.Response.Success)
{
throw new Exceptions.CannotSignInAlarmSystemWithPINException(pinLoginResponse.Response.Error);
}
secureSessionId = pinLoginResponse.Response.SecureSessionId;
}
var alarmRequest = new AlarmRequest()
{
ArmMode = Enum.GetName(typeof(Enums.AlarmArmMode), newStatus),
SecureSessionId = secureSessionId
};
var request = new RestRequest("alarm/partitions/" + paritionUuid + "/setMode", HttpMethod.Post);
request.ContentType = ContentTypes.Json;
request.AddParameter(alarmRequest);
var retVal = await _httpClient.SendWithPolicyAsync <AlarmRequestResponse>(this, request);
if (!retVal.HttpResponseMessage.IsSuccessStatusCode)
{
if (raiseExceptionWhenNotSuccesful)
{
throw new Exceptions.CannotSetAlarmStateException("Server returned: " + retVal.HttpResponseMessage.StatusCode);
}
return(false);
}
if (retVal.Content.Success)
{
return(true);
}
else
{
if (raiseExceptionWhenNotSuccesful)
{
throw new Exceptions.CannotSetAlarmStateException(retVal.Content.Error);
}
return(false);
}
}
public async Task <IActionResult> FilterAlarm([FromBody] AlarmRequest alarmRequest)
{
var snmpReciverList = await this.alarmRepo.GetFilteredSNMPReceiverHistory(AlarmStatus.GetStatusCode(alarmRequest.StatusCode), alarmRequest.FromDate, alarmRequest.ToDate, alarmRequest.MaxAlarmID);
var siteList = await this.siteRepo.GetSiteListFiltered(int.Parse(alarmRequest.Filter), alarmRequest.SiteName);
int priority = alarmRequest.Priority.Equals("All", StringComparison.InvariantCultureIgnoreCase) ? 0 : int.Parse(alarmRequest.Priority);
return(Ok(await SNMPHistoryMapping.DoMapping(siteList, snmpReciverList,
priority, alarmRequest.PageIndex, alarmRequest.PageSize, alarmRequest.Trap,
alarmRequest.SortField, alarmRequest.SortDirection)));
}
private async Task <string> OnAlarmRequestAsync(AlarmRequest alarmRequest)
{
if (alarmRequest == null || Helpers.IsNullOrEmpty(alarmRequest.AlarmMessage) || alarmRequest.HoursFromNow <= 0)
{
return("Alarm parameters are empty.");
}
await ProcessingSemaphore.WaitAsync().ConfigureAwait(false);
if (Core.AlarmManager.SetAlarm(alarmRequest.HoursFromNow, alarmRequest.AlarmMessage, alarmRequest.UseTTS, alarmRequest.Repeat, alarmRequest.RepeatHours))
{
ProcessingSemaphore.Release();
return($"Successfully set an alarm at {alarmRequest.HoursFromNow} hours from now.");
}
ProcessingSemaphore.Release();
return("Failed to set alarm.");
}
/// <summary>
/// Alarm activates, deactivates, and queries alarms regarding cluster health in async
/// </summary>
/// <param name="request">Alarm request</param>
/// <returns>Alarm Response</returns>
public async Task <AlarmResponse> AlarmAsync(AlarmRequest request)
{
AlarmResponse response = new AlarmResponse();
try
{
response = await _maintenanceClient.AlarmAsync(request);
}
catch (RpcException)
{
ResetConnection();
throw;
}
catch
{
throw;
}
return(response);
}
/// <summary>
/// Alarm activates, deactivates, and queries alarms regarding cluster health
/// </summary>
/// <param name="request">Alarm request</param>
/// <returns>Alarm Response</returns>
public AlarmResponse Alarm(AlarmRequest request)
{
AlarmResponse response = new AlarmResponse();
try
{
response = _maintenanceClient.Alarm(request);
}
catch (RpcException)
{
ResetConnection();
throw;
}
catch
{
throw;
}
return(response);
}
/// <summary>
/// Alarm activates, deactivates, and queries alarms regarding cluster health
/// </summary>
/// <param name="request">Alarm request</param>
/// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
/// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
/// <param name="cancellationToken">An optional token for canceling the call.</param>
/// <returns>Alarm Response</returns>
public AlarmResponse Alarm(AlarmRequest request, Grpc.Core.Metadata headers = null, DateTime?deadline = null,
CancellationToken cancellationToken = default) => CallEtcd((connection) => connection._maintenanceClient
.Alarm(request, headers, deadline, cancellationToken));
