Коммуникация в реальном времени с SignalR в C# на примере создания чата

// Пример простейшего хаба в SignalR
public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

// Добавление клиента в группу
public async Task JoinRoom(string roomName)
{
    await Groups.AddToGroupAsync(Context.ConnectionId, roomName);
    await Clients.Group(roomName).SendAsync("UserJoined", Context.ConnectionId);
}

// Настройка MessagePack в качестве протокола сериализации
services.AddSignalR()
    .AddMessagePackProtocol(options =>
    {
        options.FormatterResolvers = new List<MessagePack.IFormatterResolver>()
        {
            MessagePack.Resolvers.StandardResolver.Instance
        };
    });

public class ChatHub : Hub
{
    public override async Task OnConnectedAsync()
    {
        await Clients.All.SendAsync("UserConnected", Context.ConnectionId);
        await base.OnConnectedAsync();
    }
 
    public override async Task OnDisconnectedAsync(Exception exception)
    {
        await Clients.All.SendAsync("UserDisconnected", Context.ConnectionId);
        await base.OnDisconnectedAsync(exception);
    }
}

// Пример сохранения соответствия между пользователями и их ConnectionId
private static Dictionary<string, string> _userConnections = new Dictionary<string, string>();
 
public async Task Login(string username)
{
    _userConnections[username] = Context.ConnectionId;
    await Clients.All.SendAsync("UserLoggedIn", username);
}
 
public async Task SendPrivateMessage(string toUser, string message)
{
    if (_userConnections.TryGetValue(toUser, out string connectionId))
    {
        await Clients.Client(connectionId).SendAsync("ReceivePrivateMessage", Context.User.Identity.Name, message);
    }
}

[Authorize]
public class SecureHub : Hub
{
    [Authorize(Roles = "Admin")]
    public async Task AdminOnlyMethod()
    {
        // Только для администраторов
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options =>
    {
        options.AddPolicy("ClientPermission", policy =>
        {
            policy.AllowAnyHeader()
                  .AllowAnyMethod()
                  .WithOrigins("https://example.com")
                  .AllowCredentials();
        });
    });
 
    services.AddSignalR();
}

// Подключение диагностики SignalR
services.AddSignalR()
    .AddHubOptions<ChatHub>(options =>
    {
        options.EnableDetailedErrors = true;
    });

// Настройка логирования
services.AddLogging(builder =>
{
    builder.AddFilter("Microsoft.AspNetCore.SignalR", LogLevel.Debug);
    builder.AddFilter("Microsoft.AspNetCore.Http.Connections", LogLevel.Debug);
});

using Microsoft.AspNetCore.SignalR;
using System.Threading.Tasks;
 
namespace SignalRChat.Hubs
{
    public class ChatHub : Hub
    {
        public async Task SendMessage(string user, string message)
        {
            await Clients.All.SendAsync("ReceiveMessage", user, message);
        }
        
        public override async Task OnConnectedAsync()
        {
            await Clients.All.SendAsync("UserConnected", Context.ConnectionId);
            await base.OnConnectedAsync();
        }
        
        public override async Task OnDisconnectedAsync(Exception exception)
        {
            await Clients.All.SendAsync("UserDisconnected", Context.ConnectionId);
            await base.OnDisconnectedAsync(exception);
        }
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddSignalR(); // Добавляем SignalR
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ... существующий код ...
    
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
        
        // Регистрируем путь для нашего хаба
        endpoints.MapHub<ChatHub>("/chatHub");
    });
}

public async Task SendPrivateMessage(string toUserId, string fromUser, string message)
{
    await Clients.User(toUserId).SendAsync("ReceivePrivateMessage", fromUser, message);
    await Clients.Caller.SendAsync("ReceivePrivateMessage", fromUser, message);
}

private static Dictionary<string, string> _connections = new Dictionary<string, string>();
 
public async Task RegisterUser(string username)
{
    var connectionId = Context.ConnectionId;
    _connections[username] = connectionId;
    
    // Обновляем список пользователей у всех клиентов
    await Clients.All.SendAsync("UpdateUserList", _connections.Keys.ToList());
}
 
public async Task SendPrivateMessage(string toUser, string message)
{
    if (_connections.TryGetValue(toUser, out string connectionId))
    {
        var fromUser = _connections.FirstOrDefault(x => x.Value == Context.ConnectionId).Key;
        await Clients.Client(connectionId).SendAsync("ReceivePrivateMessage", fromUser, message);
        await Clients.Caller.SendAsync("ReceivePrivateMessage", fromUser, message);
    }
}

public class ChatMessage
{
    public string User { get; set; }
    public string Message { get; set; }
    public DateTime Timestamp { get; set; }
    public bool IsPrivate { get; set; }
    public string Recipient { get; set; }
}

private static readonly List<ChatMessage> _messageHistory = new List<ChatMessage>();
private const int MaxHistorySize = 50; // Ограничиваем количество хранимых сообщений
 
public async Task GetMessageHistory()
{
    await Clients.Caller.SendAsync("ReceiveMessageHistory", _messageHistory);
}
 
public async Task SendMessage(string user, string message)
{
    var chatMessage = new ChatMessage
    {
        User = user,
        Message = message,
        Timestamp = DateTime.Now,
        IsPrivate = false
    };
    
    // Добавляем сообщение в историю
    _messageHistory.Add(chatMessage);
    
    // Если история превысила максимальный размер, удаляем старые сообщения
    if (_messageHistory.Count > MaxHistorySize)
    {
        _messageHistory.RemoveAt(0);
    }
    
    await Clients.All.SendAsync("ReceiveMessage", user, message, chatMessage.Timestamp);
}
 
public async Task SendPrivateMessage(string toUser, string message)
{
    if (_connections.TryGetValue(toUser, out string connectionId))
    {
        var fromUser = _connections.FirstOrDefault(x => x.Value == Context.ConnectionId).Key;
        
        var chatMessage = new ChatMessage
        {
            User = fromUser,
            Message = message,
            Timestamp = DateTime.Now,
            IsPrivate = true,
            Recipient = toUser
        };
        
        // Добавляем приватное сообщение в историю
        _messageHistory.Add(chatMessage);
        
        // Если история превысила максимальный размер, удаляем старые сообщения
        if (_messageHistory.Count > MaxHistorySize)
        {
            _messageHistory.RemoveAt(0);
        }
        
        await Clients.Client(connectionId).SendAsync("ReceivePrivateMessage", fromUser, message, chatMessage.Timestamp);
        await Clients.Caller.SendAsync("ReceivePrivateMessage", fromUser, message, chatMessage.Timestamp);
    }
}

// Добавляем в ChatHub
public async Task UserIsTyping(string username)
{
    await Clients.Others.SendAsync("UserTyping", username);
}
 
public async Task UserStoppedTyping(string username)
{
    await Clients.Others.SendAsync("UserStoppedTyping", username);
}

public class ChatUser
{
    public string Id { get; set; }
    public string Username { get; set; }
    public string PasswordHash { get; set; }
    public List<string> Connections { get; set; } = new List<string>();
}

public interface IUserService
{
    Task<ChatUser> Authenticate(string username, string password);
    Task<ChatUser> GetById(string id);
    Task<IEnumerable<ChatUser>> GetAll();
}
 
public class UserService : IUserService
{
    // В реальном приложении эти данные хранились бы в базе
    private List<ChatUser> _users = new List<ChatUser> 
    {
        new ChatUser { Id = "1", Username = "admin", PasswordHash = BCrypt.Net.BCrypt.HashPassword("admin") },
        new ChatUser { Id = "2", Username = "user", PasswordHash = BCrypt.Net.BCrypt.HashPassword("user") }
    };
 
    public async Task<ChatUser> Authenticate(string username, string password)
    {
        var user = _users.SingleOrDefault(x => x.Username == username);
 
        if (user == null || !BCrypt.Net.BCrypt.Verify(password, user.PasswordHash))
            return null;
 
        return user;
    }
 
    public async Task<ChatUser> GetById(string id)
    {
        return _users.FirstOrDefault(x => x.Id == id);
    }
 
    public async Task<IEnumerable<ChatUser>> GetAll()
    {
        // Возвращаем копию списка без паролей
        return _users.Select(u => new ChatUser 
        { 
            Id = u.Id, 
            Username = u.Username,
            Connections = u.Connections
        });
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddSignalR();
    
    // Регистрируем сервис пользователей
    services.AddSingleton<IUserService, UserService>();
    
    // Добавляем аутентификацию с куки
    services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
        .AddCookie(options =>
        {
            options.LoginPath = "/Account/Login";
            options.ExpireTimeSpan = TimeSpan.FromDays(1);
        });
}
 
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ... существующий код ...
    
    app.UseAuthentication();
    app.UseAuthorization();
    
    // ... остальной код ...
}

public class AccountController : Controller
{
    private readonly IUserService _userService;
 
    public AccountController(IUserService userService)
    {
        _userService = userService;
    }
 
    [HttpGet]
    public IActionResult Login()
    {
        return View();
    }
 
    [HttpPost]
    public async Task<IActionResult> Login(string username, string password)
    {
        var user = await _userService.Authenticate(username, password);
 
        if (user == null)
        {
            ModelState.AddModelError("", "Неверное имя пользователя или пароль");
            return View();
        }
 
        var claims = new List<Claim>
        {
            new Claim(ClaimTypes.Name, user.Username),
            new Claim(ClaimTypes.NameIdentifier, user.Id)
        };
 
        var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
        var principal = new ClaimsPrincipal(identity);
 
        await HttpContext.SignInAsync(
            CookieAuthenticationDefaults.AuthenticationScheme,
            principal,
            new AuthenticationProperties { IsPersistent = true });
 
        return RedirectToAction("Index", "Home");
    }
 
    public async Task<IActionResult> Logout()
    {
        await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
        return RedirectToAction("Login");
    }
}

[Authorize]
public class ChatHub : Hub
{
    private readonly IUserService _userService;
    private static readonly List<ChatMessage> _messageHistory = new List<ChatMessage>();
    private const int MaxHistorySize = 50;
 
    public ChatHub(IUserService userService)
    {
        _userService = userService;
    }
 
    public override async Task OnConnectedAsync()
    {
        // Получаем ID пользователя из контекста
        var userId = Context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        var username = Context.User.Identity.Name;
 
        if (userId != null)
        {
            var user = await _userService.GetById(userId);
            
            // Добавляем текущее подключение к списку соединений пользователя
            user.Connections.Add(Context.ConnectionId);
            
            // Уведомляем всех о подключении пользователя
            await Clients.All.SendAsync("UserConnected", username, (await _userService.GetAll())
                .Select(u => u.Username).ToList());
        }
 
        await base.OnConnectedAsync();
    }
 
    public override async Task OnDisconnectedAsync(Exception exception)
    {
        var userId = Context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        var username = Context.User.Identity.Name;
 
        if (userId != null)
        {
            var user = await _userService.GetById(userId);
            
            // Удаляем соединение из списка
            user.Connections.Remove(Context.ConnectionId);
            
            // Уведомляем всех об отключении только если нет других активных соединений
            if (user.Connections.Count == 0)
            {
                await Clients.All.SendAsync("UserDisconnected", username, (await _userService.GetAll())
                    .Where(u => u.Connections.Count > 0)
                    .Select(u => u.Username).ToList());
            }
        }
 
        await base.OnDisconnectedAsync(exception);
    }
 
    // Обновленные методы для работы с авторизацией
    public async Task SendMessage(string message)
    {
        var username = Context.User.Identity.Name;
        
        var chatMessage = new ChatMessage
        {
            User = username,
            Message = message,
            Timestamp = DateTime.Now,
            IsPrivate = false
        };
        
        _messageHistory.Add(chatMessage);
        
        if (_messageHistory.Count > MaxHistorySize)
            _messageHistory.RemoveAt(0);
        
        await Clients.All.SendAsync("ReceiveMessage", username, message, chatMessage.Timestamp);
    }
 
    public async Task SendPrivateMessage(string toUsername, string message)
    {
        var fromUsername = Context.User.Identity.Name;
        var toUser = (await _userService.GetAll()).FirstOrDefault(u => u.Username == toUsername);
        
        if (toUser != null && toUser.Connections.Count > 0)
        {
            var chatMessage = new ChatMessage
            {
                User = fromUsername,
                Message = message,
                Timestamp = DateTime.Now,
                IsPrivate = true,
                Recipient = toUsername
            };
            
            _messageHistory.Add(chatMessage);
            
            if (_messageHistory.Count > MaxHistorySize)
                _messageHistory.RemoveAt(0);
            
            // Отправляем сообщение всем соединениям получателя
            foreach (var connectionId in toUser.Connections)
            {
                await Clients.Client(connectionId).SendAsync("ReceivePrivateMessage", 
                    fromUsername, message, chatMessage.Timestamp);
            }
            
            // Отправляем копию отправителю
            await Clients.Caller.SendAsync("ReceivePrivateMessage", 
                fromUsername, message, chatMessage.Timestamp);
        }
    }
}

public class ChatRoom
{
    public string Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public DateTime CreatedAt { get; set; }
    public HashSet<string> Members { get; set; } = new HashSet<string>();
}

public interface IChatRoomService
{
    Task<IEnumerable<ChatRoom>> GetAllRooms();
    Task<ChatRoom> GetRoomById(string id);
    Task<ChatRoom> CreateRoom(string name, string description, string creatorId);
    Task AddUserToRoom(string roomId, string userId);
    Task RemoveUserFromRoom(string roomId, string userId);
}
 
public class ChatRoomService : IChatRoomService
{
    private readonly List<ChatRoom> _rooms = new List<ChatRoom>
    {
        new ChatRoom
        {
            Id = "1",
            Name = "Общий чат",
            Description = "Комната для всех пользователей",
            CreatedAt = DateTime.Now,
            Members = new HashSet<string>()
        }
    };
 
    public async Task<IEnumerable<ChatRoom>> GetAllRooms()
    {
        return _rooms;
    }
 
    public async Task<ChatRoom> GetRoomById(string id)
    {
        return _rooms.FirstOrDefault(r => r.Id == id);
    }
 
    public async Task<ChatRoom> CreateRoom(string name, string description, string creatorId)
    {
        var room = new ChatRoom
        {
            Id = Guid.NewGuid().ToString(),
            Name = name,
            Description = description,
            CreatedAt = DateTime.Now,
            Members = new HashSet<string> { creatorId }
        };
 
        _rooms.Add(room);
        return room;
    }
 
    public async Task AddUserToRoom(string roomId, string userId)
    {
        var room = await GetRoomById(roomId);
        if (room != null)
        {
            room.Members.Add(userId);
        }
    }
 
    public async Task RemoveUserFromRoom(string roomId, string userId)
    {
        var room = await GetRoomById(roomId);
        if (room != null)
        {
            room.Members.Remove(userId);
        }
    }
}

services.AddSingleton<IChatRoomService, ChatRoomService>();

[Authorize]
public class ChatHub : Hub
{
    private readonly IUserService _userService;
    private readonly IChatRoomService _roomService;
    private static readonly Dictionary<string, List<ChatMessage>> _roomMessageHistory = 
        new Dictionary<string, List<ChatMessage>>();
    private const int MaxHistorySize = 50;
 
    public ChatHub(IUserService userService, IChatRoomService roomService)
    {
        _userService = userService;
        _roomService = roomService;
    }
 
    // Метод для получения списка комнат
    public async Task GetRooms()
    {
        var rooms = await _roomService.GetAllRooms();
        await Clients.Caller.SendAsync("ReceiveRooms", rooms);
    }
 
    // Метод для создания новой комнаты
    public async Task CreateRoom(string name, string description)
    {
        var userId = Context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        if (userId != null)
        {
            var room = await _roomService.CreateRoom(name, description, userId);
            // Инициализируем историю сообщений для новой комнаты
            _roomMessageHistory[room.Id] = new List<ChatMessage>();
            
            // Оповещаем всех о новой комнате
            await Clients.All.SendAsync("RoomCreated", room);
        }
    }
 
    // Метод для присоединения к комнате
    public async Task JoinRoom(string roomId)
    {
        var userId = Context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        var username = Context.User.Identity.Name;
        
        if (userId != null)
        {
            // Добавляем пользователя в комнату в нашей модели
            await _roomService.AddUserToRoom(roomId, userId);
            
            // Добавляем соединение в группу SignalR
            await Groups.AddToGroupAsync(Context.ConnectionId, roomId);
            
            // Получаем историю сообщений комнаты
            if (!_roomMessageHistory.ContainsKey(roomId))
            {
                _roomMessageHistory[roomId] = new List<ChatMessage>();
            }
            
            // Отправляем историю сообщений комнаты
            await Clients.Caller.SendAsync("ReceiveRoomHistory", roomId, _roomMessageHistory[roomId]);
            
            // Оповещаем участников комнаты о новом пользователе
            await Clients.Group(roomId).SendAsync("UserJoinedRoom", roomId, username);
        }
    }
 
    // Метод для выхода из комнаты
    public async Task LeaveRoom(string roomId)
    {
        var userId = Context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        var username = Context.User.Identity.Name;
        
        if (userId != null)
        {
            // Удаляем пользователя из комнаты в нашей модели
            await _roomService.RemoveUserFromRoom(roomId, userId);
            
            // Удаляем соединение из группы SignalR
            await Groups.RemoveFromGroupAsync(Context.ConnectionId, roomId);
            
            // Оповещаем участников комнаты об уходе пользователя
            await Clients.Group(roomId).SendAsync("UserLeftRoom", roomId, username);
        }
    }
 
    // Метод для отправки сообщения в комнату
    public async Task SendRoomMessage(string roomId, string message)
    {
        var username = Context.User.Identity.Name;
        
        // Создаем сообщение
        var chatMessage = new ChatMessage
        {
            User = username,
            Message = message,
            Timestamp = DateTime.Now,
            IsPrivate = false
        };
        
        // Добавляем сообщение в историю комнаты
        if (!_roomMessageHistory.ContainsKey(roomId))
        {
            _roomMessageHistory[roomId] = new List<ChatMessage>();
        }
        
        _roomMessageHistory[roomId].Add(chatMessage);
        
        // Ограничиваем размер истории
        if (_roomMessageHistory[roomId].Count > MaxHistorySize)
        {
            _roomMessageHistory[roomId].RemoveAt(0);
        }
        
        // Отправляем сообщение всем участникам комнаты
        await Clients.Group(roomId).SendAsync("ReceiveRoomMessage", roomId, username, message, chatMessage.Timestamp);
    }
}

// Установка пакета для Redis
// Install-Package StackExchange.Redis
 
// Настройка подключения к Redis
var redis = ConnectionMultiplexer.Connect("localhost:6379");
var db = redis.GetDatabase();
 
// Сохранение состояния пользователя
public async Task SaveUserState(string userId, UserState state)
{
    string serializedState = JsonConvert.SerializeObject(state);
    await db.StringSetAsync($"user:{userId}:state", serializedState);
}
 
// Восстановление состояния
public async Task<UserState> GetUserState(string userId)
{
    string serializedState = await db.StringGetAsync($"user:{userId}:state");
    if (string.IsNullOrEmpty(serializedState))
        return null;
    
    return JsonConvert.DeserializeObject<UserState>(serializedState);
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR()
        .AddStackExchangeRedis("localhost:6379", options =>
        {
            options.Configuration.ChannelPrefix = "SignalRChat";
        });
}

services.AddSignalR()
    .AddNewtonsoftJsonProtocol()
    .AddHubOptions<ChatHub>(options =>
    {
        options.EnableDetailedErrors = true;
    });

services.AddApplicationInsightsTelemetry();
services.AddSignalR().AddAzureSignalR(options =>
{
    options.ConnectionString = Configuration["Azure:SignalR:ConnectionString"];
    options.ApplicationInsights.EnableMetrics = true;
});

private static readonly Counter MessagesSent = Metrics.CreateCounter(
    "signalr_messages_sent_total", 
    "Total number of messages sent through SignalR"
);
 
public async Task SendMessage(string user, string message)
{
    await Clients.All.SendAsync("ReceiveMessage", user, message);
    MessagesSent.Inc(); // Увеличиваем счетчик
}

[Authorize(Policy = "AdminOnly")]
public async Task AdminBroadcast(string message)
{
    await Clients.All.SendAsync("ReceiveAdminMessage", message);
}

public class CustomAuthorizationFilter : IHubFilter
{
    public async ValueTask<object> InvokeMethodAsync(
        HubInvocationContext invocationContext, 
        Func<HubInvocationContext, ValueTask<object>> next)
    {
        // Здесь можно проверить права доступа на основе контекста вызова
        if (invocationContext.HubMethodName == "SendMessage")
        {
            var user = invocationContext.Context.User;
            // Проверка прав...
        }
        
        return await next(invocationContext);
    }
}
 
// Регистрация фильтра
services.AddSignalR(options =>
{
    options.AddFilter<CustomAuthorizationFilter>();
});

app.UseCors(builder =>
{
    builder.WithOrigins("https://trusted-domain.com")
           .AllowAnyMethod()
           .AllowAnyHeader()
           .AllowCredentials(); // Необходимо для SignalR
});

services.AddSignalR()
  .AddMessagePackProtocol(options =>
  {
      options.FormatterResolvers = new List<MessagePack.IFormatterResolver>()
      {
          MessagePack.Resolvers.StandardResolver.Instance
      };
  });

// Серверная часть
public async IAsyncEnumerable<int> StreamData(int count, int delay, [EnumeratorCancellation] CancellationToken cancellationToken)
{
  for (var i = 0; i < count; i++)
  {
      // Проверка отмены потока клиентом
      cancellationToken.ThrowIfCancellationRequested();
      
      yield return i;
      await Task.Delay(delay, cancellationToken);
  }
}

// Подписка на события в сервисе уведомлений
public class NotificationService : IHostedService
{
  private readonly IEventBus _eventBus;
  private readonly IHubContext<NotificationHub> _hubContext;
 
  public NotificationService(IEventBus eventBus, IHubContext<NotificationHub> hubContext)
  {
      _eventBus = eventBus;
      _hubContext = hubContext;
  }
 
  public Task StartAsync(CancellationToken cancellationToken)
  {
      _eventBus.Subscribe<OrderCreatedEvent, OrderCreatedEventHandler>();
      return Task.CompletedTask;
  }
 
  // Обработчик события
  public class OrderCreatedEventHandler : IEventHandler<OrderCreatedEvent>
  {
      private readonly IHubContext<NotificationHub> _hubContext;
 
      public OrderCreatedEventHandler(IHubContext<NotificationHub> hubContext)
      {
          _hubContext = hubContext;
      }
 
      public async Task Handle(OrderCreatedEvent @event)
      {
          // Отправка уведомления клиентам
          await _hubContext.Clients.User(@event.UserId).SendAsync("OrderCreated", @event);
      }
  }
}

public class BackgroundMessageService : BackgroundService
{
  private readonly IHubContext<ChatHub> _hubContext;
 
  public BackgroundMessageService(IHubContext<ChatHub> hubContext)
  {
      _hubContext = hubContext;
  }
 
  protected override async Task ExecuteAsync(CancellationToken stoppingToken)
  {
      while (!stoppingToken.IsCancellationRequested)
      {
          // Например, периодическая отправка системных сообщений
          await _hubContext.Clients.All.SendAsync("ReceiveSystemMessage", 
              $"Системное сообщение: {DateTime.Now}", stoppingToken);
          
          await Task.Delay(TimeSpan.FromMinutes(10), stoppingToken);
      }
  }
}