Oda/managing-apps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace cache by concurrentDictionary task

Browse Source
This commit is contained in:
cryptooda
2024-07-12 22:05:34 +07:00
parent dfe92d787e
commit 6718d08448
1 changed files with 59 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
src/Managing.Application/ManageBot/BotService.cs
View File

@@ -1,3 +1,4 @@
using System.Collections.Concurrent;
using Managing.Application.Abstractions;
using Managing.Application.Abstractions.Services;
using Managing.Application.Bots;
@@ -14,20 +15,20 @@ namespace Managing.Application.ManageBot
public class BotService : IBotService
{
private readonly IBotRepository _botRepository;
private readonly ITaskCache _taskCache;
private readonly IExchangeService _exchangeService;
private readonly IMessengerService _messengerService;
private readonly IAccountService _accountService;
private readonly ILogger<TradingBot> _tradingBotLogger;
private readonly ITradingService _tradingService;
private ConcurrentDictionary<string, BotTaskWrapper> _botTasks =
new ConcurrentDictionary<string, BotTaskWrapper>();
public BotService(IBotRepository botRepository, ITaskCache taskCache, IExchangeService exchangeService,
public BotService(IBotRepository botRepository, IExchangeService exchangeService,
IMessengerService messengerService, IAccountService accountService, ILogger<TradingBot> tradingBotLogger,
ITradingService tradingService)
{
_botRepository = botRepository;
_taskCache = taskCache;
_exchangeService = exchangeService;
_messengerService = messengerService;
_accountService = accountService;
@@ -66,20 +67,40 @@ namespace Managing.Application.ManageBot
_botRepository.InsertBotAsync(botBackup);
}
public class BotTaskWrapper
{
public Task Task { get; private set; }
public Type BotType { get; private set; }
public object BotInstance { get; private set; } // Add this line
public BotTaskWrapper(Task task, Type botType, object botInstance) // Update constructor
{
Task = task;
BotType = botType;
BotInstance = botInstance; // Set the bot instance
}
}
public void AddSimpleBotToCache(IBot bot)
{
_taskCache.AddOrGetExisting(bot.GetName(), () => Task.FromResult(bot));
var botTask =
new BotTaskWrapper(Task.Run(() => bot.Start()), bot.GetType(), bot); // Pass bot as the instance
_botTasks.AddOrUpdate(bot.GetName(), botTask, (key, existingVal) => botTask);
}
public void AddTradingBotToCache(ITradingBot bot)
{
_taskCache.AddOrGetExisting(bot.GetName(), () => Task.FromResult(bot));
var botTask = new BotTaskWrapper(Task.Run(() => bot.Start()), bot.GetType(), bot);
_botTasks.AddOrUpdate(bot.GetName(), botTask, (key, existingVal) => botTask);
}
public List<ITradingBot> GetActiveBots()
{
var cachedTask = _taskCache.GetCache<AsyncLazy<ITradingBot>>();
return cachedTask.Select(item => item.Value.Result).ToList();
return _botTasks.Values
.Where(wrapper => typeof(ITradingBot).IsAssignableFrom(wrapper.BotType))
.Select(wrapper => wrapper.BotInstance as ITradingBot)
.Where(bot => bot != null)
.ToList();
}
public IEnumerable<BotBackup> GetSavedBots()
@@ -89,46 +110,47 @@ namespace Managing.Application.ManageBot
public void StartBotFromBackup(BotBackup backupBot)
{
object bot = null;
Task botTask = null;
switch (backupBot.BotType)
{
case Enums.BotType.SimpleBot:
Func<Task<IBot>> simpleBot = () =>
Task.FromResult(CreateSimpleBot(backupBot.Name, null));
var bot1 = _taskCache.AddOrGetExisting(backupBot.Name, simpleBot).Result;
bot1.LoadBackup(backupBot);
bot1.Start();
bot = CreateSimpleBot(backupBot.Name,
null); // Assuming null is an acceptable parameter for workflow
botTask = Task.Run(() => ((IBot)bot).Start());
break;
case Enums.BotType.ScalpingBot:
var data = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
Func<Task<ITradingBot>> scalpingBot = () => Task.FromResult(CreateScalpingBot(
data.AccountName,
data.MoneyManagement,
data.Name,
data.Ticker,
data.Scenario,
data.Timeframe,
data.IsForWatchingOnly));
var bot2 = _taskCache.AddOrGetExisting(backupBot.Name, scalpingBot).Result;
bot2.LoadBackup(backupBot);
bot2.Start();
var scalpingBotData = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
bot = CreateScalpingBot(
scalpingBotData.AccountName,
scalpingBotData.MoneyManagement,
backupBot.Name,
scalpingBotData.Ticker,
scalpingBotData.Scenario,
scalpingBotData.Timeframe,
scalpingBotData.IsForWatchingOnly);
botTask = Task.Run(() => ((ITradingBot)bot).Start());
break;
case Enums.BotType.FlippingBot:
var dataFlippingBot = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
Func<Task<ITradingBot>> flippingBot = () => Task.FromResult(CreateFlippingBot(
dataFlippingBot.AccountName,
dataFlippingBot.MoneyManagement,
dataFlippingBot.Name,
dataFlippingBot.Ticker,
dataFlippingBot.Scenario,
dataFlippingBot.Timeframe,
dataFlippingBot.IsForWatchingOnly));
var bot3 = _taskCache.AddOrGetExisting(backupBot.Name, flippingBot).Result;
bot3.LoadBackup(backupBot);
bot3.Start();
var flippingBotData = JsonConvert.DeserializeObject<TradingBotBackup>(backupBot.Data);
bot = CreateFlippingBot(
flippingBotData.AccountName,
flippingBotData.MoneyManagement,
backupBot.Name,
flippingBotData.Ticker,
flippingBotData.Scenario,
flippingBotData.Timeframe,
flippingBotData.IsForWatchingOnly);
botTask = Task.Run(() => ((ITradingBot)bot).Start());
break;
}
;
if (bot != null && botTask != null)
{
var botWrapper = new BotTaskWrapper(botTask, bot.GetType(), bot);
_botTasks.AddOrUpdate(backupBot.Name, botWrapper, (key, existingVal) => botWrapper);
}
}
public IBot CreateSimpleBot(string botName, Workflow workflow)