public async Task SendAsync(string type, string sender, string message)
{
if (type.Equals(ChannelTypes.Monitor, StringComparison.InvariantCultureIgnoreCase))
{
await _sender.SendAsync(type, sender, message);
return;
}
await _sender.SendAsync(ChannelTypes.MarginTrading, sender, GetSlackMsg(message));
}
public void SetMode(bool isEnabled)
{
IsEnabled = isEnabled;
_slackNotificationsSender.SendAsync(ChannelTypes.Monitor, $"Backend {_settings.Env}",
$"Maintenance mode is {(isEnabled ? "ENABLED" : "DISABLED")}");
}
public void AlertRiskOfficer(string assetPairId, string message, EventTypeEnum eventType)
{
var(slackChannelType, traceLevel) = _alertSeverityLevelService.GetLevel(eventType);
Trace.Write(traceLevel, assetPairId, $"{nameof(AlertRiskOfficer)}: {message}", new {});
if (!string.IsNullOrWhiteSpace(slackChannelType))
{
_slack.SendAsync(slackChannelType, "MT OrderbookAggregator", message);
}
}
public async Task Process()
{
var multisigsWithOldRequests = await PrepareExistingRequests();
var channels = await GetChannels(Constants.BtcAssetId);
var ordered = channels.Balances.Where(x => x.ClientAmount == 0).OrderByDescending(x => x.HubAmount);
var broadcastedCount = 0;
var maxBroadcastCount = await _offchainSettingsRepository.Get(Constants.MaxCommitmentBroadcastCountSettingsKey, MaxBroadcastCount);
try
{
foreach (var item in ordered)
{
if (broadcastedCount >= maxBroadcastCount)
{
return;
}
if (multisigsWithOldRequests.ContainsKey(item.Multisig))
{
try
{
await _logger.WriteInfoAsync(nameof(BroadcastCommitmentFunction), nameof(Process),
$"Multisig: {item.Multisig}", "Start commitment broadcasting");
var response = await BroadcastCommitment(item.Multisig, Constants.BtcAssetId);
broadcastedCount++;
await _offchainRequestService.Complete(multisigsWithOldRequests[item.Multisig]);
await _logger.WriteInfoAsync(nameof(BroadcastCommitmentFunction), nameof(Process),
$"Multisig: {item.Multisig}, hash: {response.TransactionHash}",
"Finish commitment broadcasting");
}
catch (Exception e)
{
await _logger.WriteErrorAsync(nameof(BroadcastCommitmentFunction), nameof(Process),
$"Multisig: {item.Multisig}", e);
}
}
}
}
finally
{
if (broadcastedCount > 0)
{
await _slackNotificationsSender.SendAsync("Offchain", ":information_source:", $"New {broadcastedCount} hub commitments were broadcasted");
}
}
}
private async Task GenerateRequestsForAsset(string asset, decimal minAmount, DateTime?lastActivity = null)
{
var createdCount = 0;
try
{
var channels = await GetChannels(asset);
var existingRequests = await PrepareExistingRequests(asset);
foreach (var channel in channels.Balances)
{
// check balance
if (channel.HubAmount < minAmount || existingRequests.Contains(channel.Multisig))
{
continue;
}
//check last activity date
if (lastActivity != null && channel.UpdateDt > lastActivity)
{
continue;
}
var client = await _walletCredentialsRepository.GetClientIdByMultisig(channel.Multisig);
if (string.IsNullOrWhiteSpace(client))
{
continue;
}
await _offchainRequestService.CreateHubCashoutRequests(asset, client);
createdCount++;
}
}
finally
{
if (createdCount != 0)
{
await _slackNotificationsSender.SendAsync("Offchain", ":information_source:", $"New {createdCount} hub requests were created for {asset}. (min. {minAmount})");
}
await _log.WriteInfoAsync(nameof(ManualHubCashoutFunction), nameof(GenerateRequestsForAsset), $"Asset: {asset}, requests created: {createdCount}", "Finished");
}
}
public async Task WriteInfoAsync(string component, string process, string context, string info, DateTime?dateTime = null)
{
if (!_isInfoEnabled)
{
return;
}
if (await _spamGuard.ShouldBeMutedAsync(LogLevel.Info, component, process))
{
return;
}
var message = $"{GetComponentName(component)} : {process} : {info} : {context}";
await _sender.SendAsync(_channel, ":information_source:", message);
}
/// <inheritdoc />
public void Notify([NotNull] string healthMessage, [CanBeNull] object context)
{
var sender = $":loudspeaker: {_appName} {_appVersion} : {_envInfo}";
var messageBuilder = new StringBuilder();
messageBuilder.Append(healthMessage);
if (context != null)
{
messageBuilder.AppendLine();
messageBuilder.Append(LogContextConversion.ConvertToString(context));
}
var message = messageBuilder.ToString();
var tasks = new List <Task> {
_slackSender.SendMonitorAsync(message, sender)
};
tasks.AddRange(_customChannels.Select(c => _slackSender.SendAsync(c, sender, message)));
Task.WhenAll(tasks).ConfigureAwait(false).GetAwaiter().GetResult();
}
protected void WriteInfoToLogAndSlack(string infoMessage)
{
_logger.WriteInfoAsync(ApplicationInfo.ApplicationFullName, null, null, infoMessage);
_slackNotificationsSender.SendAsync(ChannelTypes.MarginTrading, ApplicationInfo.ApplicationFullName,
infoMessage);
}
public async Task SendAsync(string type, string sender, string message)
{
await _sender.SendAsync(_channelType, sender, GetSlackMsg(message));
}
public Task SendRawAsync(string type, string sender, string message)
{
return(_sender?.SendAsync(type, sender, message) ?? Task.CompletedTask);
}
public async Task Send(AzureAlertNotification notification)
{
var sender = notification.Context.ResourceName;
var msg = FormatMessage(notification);
await _slackNotificationsSender.SendAsync(Const.SlackMsgType, sender, msg);
}
public async Task FinanceWarningAsync(string message)
{
await _slackNotificationsSender.SendAsync("Financewarnings", "bitcoin service", message);
}
public async Task SendNotification(string type, string message, string sender)
{
await _slackClient.SendAsync(type, sender, message);
}
public static Task SendInfoAsync(this ISlackNotificationsSender src, string message, string sender = null)
{
return(src.SendAsync("Info", sender ?? ":exclamation:", message));
}
public static Task SendMonitorAsync(this ISlackNotificationsSender src, string message, string sender = null)
{
return(src.SendAsync("Monitor", sender ?? ":information_source:", message));
}
public static Task SendWarningAsync(this ISlackNotificationsSender src, string message, string sender = null)
{
return(src.SendAsync("Warning", sender ?? ":warning:", message));
}
