/// <inheritdoc /> public void NewGroup(SessionInfo session, NewGroupRequest request, CancellationToken cancellationToken) { if (session == null) { throw new InvalidOperationException("Session is null!"); } if (request == null) { throw new InvalidOperationException("Request is null!"); } // Locking required to access list of groups. lock (_groupsLock) { // Make sure that session has not joined another group. if (_sessionToGroupMap.ContainsKey(session.Id)) { var leaveGroupRequest = new LeaveGroupRequest(); LeaveGroup(session, leaveGroupRequest, cancellationToken); } var group = new Group(_loggerFactory, _userManager, _sessionManager, _libraryManager); _groups[group.GroupId] = group; if (!_sessionToGroupMap.TryAdd(session.Id, group)) { throw new InvalidOperationException("Could not add session to group!"); } UpdateSessionsCounter(session.UserId, 1); group.CreateGroup(session, request, cancellationToken); } }
public void LeaveGroupRequest( [Values("test", "a groupId")] string groupId, [Values("", "an existing member")] string memberId) { var request = new LeaveGroupRequest(groupId, memberId); request.AssertCanEncodeDecodeRequest(0); }
public ActionResult SyncPlayLeaveGroup() { var currentSession = RequestHelpers.GetSession(_sessionManager, _authorizationContext, Request); var syncPlayRequest = new LeaveGroupRequest(); _syncPlayManager.LeaveGroup(currentSession, syncPlayRequest, CancellationToken.None); return(NoContent()); }
public async Task <ActionResult> SyncPlayLeaveGroup() { var currentSession = await RequestHelpers.GetSession(_sessionManager, _authorizationContext, Request).ConfigureAwait(false); var syncPlayRequest = new LeaveGroupRequest(); _syncPlayManager.LeaveGroup(currentSession, syncPlayRequest, CancellationToken.None); return(NoContent()); }
public async Task <IActionResult> LeaveGroup([FromQuery] LeaveGroupRequest request) { var response = await mediator.Send(request); logger.LogResponse($"User #{HttpContext.GetCurrentUserId()} leaved group #{request.GroupId}", response.Error); return(this.CreateResponse(response)); }
private void OnSessionEnded(object sender, SessionEventArgs e) { var session = e.SessionInfo; if (_sessionToGroupMap.TryGetValue(session.Id, out var group)) { var leaveGroupRequest = new LeaveGroupRequest(); LeaveGroup(session, leaveGroupRequest, CancellationToken.None); } }
public LeaveGroupResponse LeaveGroup(ISession session, LeaveGroupRequest request) { KickParticipants(session, new KickParticipantsRequest { GroupId = request.GroupId, ParticipantIds = new List <long>() { session.UserId } }); return(request.CreateResponse <LeaveGroupResponse>()); }
/// <inheritdoc /> public void LeaveGroup(SessionInfo session, LeaveGroupRequest request, CancellationToken cancellationToken) { if (session == null) { throw new InvalidOperationException("Session is null!"); } if (request == null) { throw new InvalidOperationException("Request is null!"); } // Locking required to access list of groups. lock (_groupsLock) { if (_sessionToGroupMap.TryGetValue(session.Id, out var group)) { // Group lock required to let other requests end first. lock (group) { if (_sessionToGroupMap.TryRemove(session.Id, out var tempGroup)) { if (!tempGroup.GroupId.Equals(group.GroupId)) { throw new InvalidOperationException("Session was in wrong group!"); } } else { throw new InvalidOperationException("Could not remove session from group!"); } UpdateSessionsCounter(session.UserId, -1); group.SessionLeave(session, request, cancellationToken); if (group.IsGroupEmpty()) { _logger.LogInformation("Group {GroupId} is empty, removing it.", group.GroupId); _groups.Remove(group.GroupId, out _); } } } else { _logger.LogWarning("Session {SessionId} does not belong to any group.", session.Id); var error = new GroupUpdate <string>(Guid.Empty, GroupUpdateType.NotInGroup, string.Empty); _sessionManager.SendSyncPlayGroupUpdate(session, error, CancellationToken.None); return; } } }
public async Task DisposeAsync() { if (Interlocked.Increment(ref _disposeCount) != 1) { await _disposePromise.Task; return; } try { Router.Log.Debug(() => LogEvent.Create($"Disposing Consumer {{GroupId:{GroupId},MemberId:{MemberId}}}")); _disposeToken.Cancel(); _fetchSemaphore.Dispose(); _joinSemaphore.Dispose(); _syncSemaphore.Dispose(); try { var batches = Interlocked.Exchange(ref _batches, ImmutableDictionary <TopicPartition, IMessageBatch> .Empty); await Task.WhenAll(batches.Values.Select(b => b.CommitMarkedAsync(CancellationToken.None))).ConfigureAwait(false); foreach (var batch in batches.Values) { batch.Dispose(); } } catch (Exception ex) { Router.Log.Info(() => LogEvent.Create(ex)); } _assignment = null; try { await Task.WhenAny(_heartbeatTask, _stateChangeTask, Task.Delay(TimeSpan.FromSeconds(1), CancellationToken.None)).ConfigureAwait(false); if (_leaveOnDispose) { var request = new LeaveGroupRequest(GroupId, MemberId); await Router.SendAsync(request, GroupId, CancellationToken.None, retryPolicy : Retry.None).ConfigureAwait(false); } } catch (Exception ex) { Router.Log.Info(() => LogEvent.Create(ex)); } if (!_leaveRouterOpen) { await Router.DisposeAsync(); } _disposeToken.Dispose(); } finally { _disposePromise.TrySetResult(true); } }
public LeaveGroupResponse LeaveGroup() { if (String.IsNullOrWhiteSpace(_memberId)) { throw new InvalidOperationException(); } var request = new LeaveGroupRequest(_groupId, _memberId); var response = (LeaveGroupResponse)_client.SubmitRequest(_coordinateBroker, request); Trace.TraceInformation("{0:HH:mm:ss.fff} [{1:d2}] #6 Member '{2}' leave group '{3}'", DateTime.Now, Thread.CurrentThread.ManagedThreadId, _memberId, _groupId); _heartbeatTimer.Change(Timeout.Infinite, Timeout.Infinite); response.TryThrowFirstErrorOccured(); return(response); }
public void LeaveGroupRequest() { var request = new LeaveGroupRequest(); request.GroupId = Guid.NewGuid().ToString(); request.MemberId = Guid.NewGuid().ToString(); Stream binary1 = new MemoryStream(); request.Serialize(binary1); binary1.Seek(0L, SeekOrigin.Begin); var request2 = new LeaveGroupRequest(); request2.Deserialize(binary1); var compareLogic = new CompareLogic(); var result = compareLogic.Compare(request, request2); Assert.True(result.AreEqual); Stream binary2 = new MemoryStream(); request.Serialize(binary2); Assert.Equal(binary1.Length, binary2.Length); using (var stream1 = new MemoryStream()) using (var stream2 = new MemoryStream()) { binary1.Seek(0L, SeekOrigin.Begin); binary1.CopyTo(stream1); binary2.Seek(0L, SeekOrigin.Begin); binary2.CopyTo(stream2); Assert.Equal(stream1.Length, stream2.Length); stream1.Seek(0L, SeekOrigin.Begin); var bytes1 = stream1.ToArray(); stream2.Seek(0L, SeekOrigin.Begin); var bytes2 = stream2.ToArray(); Assert.Equal(bytes1.Length, bytes2.Length); for (int i = 0; i < bytes1.Length; i++) { Assert.Equal(bytes1[i], bytes2[i]); } } }
public async override Task <LeaveGroupResponse> LeaveGroup(LeaveGroupRequest request, ServerCallContext context) { try { var result = new LeaveGroupResponse { Success = true }; var userIdentifier = GetUserIdentifier(context); var user = await _groupStore.GetUser(userIdentifier); if (user != null) { var userGroup = await _groupStore.GetUserGroup(user.Id, request.Id); if (userGroup != null) { await _groupStore.RemoveUserGroup(userGroup); } else { result.Success = false; result.Message = "User is not connected to group"; } } else { result.Success = false; result.Message = "User does not exist"; } return(result); } catch (Exception ex) { _logger.LogError(ex, ex.Message); return(new LeaveGroupResponse { Success = false, Message = ex.Message }); } }
/// <inheritdoc /> public void JoinGroup(SessionInfo session, JoinGroupRequest request, CancellationToken cancellationToken) { if (session == null) { throw new InvalidOperationException("Session is null!"); } if (request == null) { throw new InvalidOperationException("Request is null!"); } var user = _userManager.GetUserById(session.UserId); // Locking required to access list of groups. lock (_groupsLock) { _groups.TryGetValue(request.GroupId, out Group group); if (group == null) { _logger.LogWarning("Session {SessionId} tried to join group {GroupId} that does not exist.", session.Id, request.GroupId); var error = new GroupUpdate <string>(Guid.Empty, GroupUpdateType.GroupDoesNotExist, string.Empty); _sessionManager.SendSyncPlayGroupUpdate(session, error, CancellationToken.None); return; } // Group lock required to let other requests end first. lock (group) { if (!group.HasAccessToPlayQueue(user)) { _logger.LogWarning("Session {SessionId} tried to join group {GroupId} but does not have access to some content of the playing queue.", session.Id, group.GroupId.ToString()); var error = new GroupUpdate <string>(group.GroupId, GroupUpdateType.LibraryAccessDenied, string.Empty); _sessionManager.SendSyncPlayGroupUpdate(session, error, CancellationToken.None); return; } if (_sessionToGroupMap.TryGetValue(session.Id, out var existingGroup)) { if (existingGroup.GroupId.Equals(request.GroupId)) { // Restore session. UpdateSessionsCounter(session.UserId, 1); group.SessionJoin(session, request, cancellationToken); return; } var leaveGroupRequest = new LeaveGroupRequest(); LeaveGroup(session, leaveGroupRequest, cancellationToken); } if (!_sessionToGroupMap.TryAdd(session.Id, group)) { throw new InvalidOperationException("Could not add session to group!"); } UpdateSessionsCounter(session.UserId, 1); group.SessionJoin(session, request, cancellationToken); } } }
public async Task <IActionResult> LeaveGroup(LeaveGroupRequest request, [FromServices] IHandler <LeaveGroupRequest, ObjectResult> handler) { return(await handler.Handle(request)); }
public Task <LeaveGroupResponse> LeaveGroup(LeaveGroupRequest request) { return(_connectionManager.SendRequestAndWaitResponse <LeaveGroupResponse>(request)); }