/// <summary> /// Guarda una reservacion ficticia en Opera para clientes Outhouse /// </summary> /// <param name="hotel"></param> /// <param name="folio"></param> /// <param name="FirstName"></param> /// <param name="LastName"></param> /// <param name="Company"></param> /// <param name="Application"></param> /// <param name="MembershipType"></param> /// <returns></returns> /// <history> /// [vipacheco] 27/Mayo/2016 Created /// </history> public static long Origos_reservas_ficticias_Guardar(string hotel, int folio, string FirstName, string LastName) { IntegerResponse Response = null; // Configuramos el Request origos_reservas_ficticiasRequest Request = new origos_reservas_ficticiasRequest() { data = new origos_reservas_ficticias { hotel = hotel, folio = folio, FirstName = FirstName, LastName = LastName } }; // Invocamos al servicio web Response = Current.Origos_reservas_ficticias_Guardar(Request); // Si ocurrio un error if (Response.HasErrors) { MessageBox.Show(Response.ExceptionInfo.Message, "Origos_reservas_ficticias_Guardar"); } return(Response.Numero); }
// // Write a object instance to data output stream // public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) { IntegerResponse info = (IntegerResponse)o; base.LooseMarshal(wireFormat, o, dataOut); dataOut.Write(info.Result); }
// // Write a object instance to data output stream // public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) { base.TightMarshal2(wireFormat, o, dataOut, bs); IntegerResponse info = (IntegerResponse)o; dataOut.Write(info.Result); }
// // Un-marshal an object instance from the data input stream // public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) { base.LooseUnmarshal(wireFormat, o, dataIn); IntegerResponse info = (IntegerResponse)o; info.Result = dataIn.ReadInt32(); }
// // Un-marshal an object instance from the data input stream // public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) { base.TightUnmarshal(wireFormat, o, dataIn, bs); IntegerResponse info = (IntegerResponse)o; info.Result = dataIn.ReadInt32(); }
// // Write the booleans that this object uses to a BooleanStream // public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) { IntegerResponse info = (IntegerResponse)o; int rc = base.TightMarshal1(wireFormat, info, bs); return(rc + 4); }
public override Task <IntegerResponse> GetTeamID(NameRequest request, ServerCallContext context) { var tmp = new IntegerResponse { Number = GetTeamIdFromName(request.TeamName) }; return(System.Threading.Tasks.Task.FromResult(tmp)); }
public override Task <IntegerResponse> GetTeamID(NameRequest request, ServerCallContext context) { IntegerResponse tmp = new IntegerResponse(); DBConnection.Open(); tmp.Number = GetTeamIdFromName(request.TeamName); DBConnection.Close(); return(System.Threading.Tasks.Task.FromResult(tmp)); }
public IntegerResponse GetVolumeState() { var response = new IntegerResponse() { Data = ITunesService.Instance.Volume, Name = nameof(ITunesService.Instance.Volume) }; return(response); }
public void Parse_Throws_MessageReadException_On_Missing_Data() { var msg = new MessageBuilder() .WriteCode(MessageCode.Server.GetPeerAddress) .Build(); var ex = Record.Exception(() => IntegerResponse.FromByteArray <MessageCode.Server>(msg)); Assert.NotNull(ex); Assert.IsType <MessageReadException>(ex); }
public void Parse_Returns_Expected_Data() { var num = new Random().Next(); var msg = new MessageBuilder() .WriteCode(MessageCode.Server.GetPeerAddress) .WriteInteger(num) .Build(); var response = IntegerResponse.FromByteArray <MessageCode.Server>(msg); Assert.Equal(num, response); }
public IActionResult PostVolumeState([FromBody] IntegerRequest volumeParameter) { if (volumeParameter.Name == null || !volumeParameter.Name.Equals("Volume")) { return(BadRequest(volumeParameter)); } if (!ITunesService.Instance.IsActive) { return(new StatusCodeResult((int)HttpStatusCode.ServiceUnavailable)); } var newVolume = ITunesService.Instance.ChangeVolume(volumeParameter.Data); var volumeValue = newVolume ?? 0; var response = new IntegerResponse() { Data = volumeValue, Name = nameof(ITunesService.Instance.Volume) }; return(Ok(response)); }
/// <summary> /// Handles incoming messages. /// </summary> /// <param name="sender">The <see cref="IMessageConnection"/> instance from which the message originated.</param> /// <param name="message">The message.</param> public async void HandleMessage(object sender, byte[] message) { var code = new MessageReader <MessageCode.Server>(message).ReadCode(); Diagnostic.Debug($"Server message received: {code}"); try { switch (code) { case MessageCode.Server.ParentMinSpeed: case MessageCode.Server.ParentSpeedRatio: case MessageCode.Server.WishlistInterval: SoulseekClient.Waiter.Complete(new WaitKey(code), IntegerResponse.FromByteArray <MessageCode.Server>(message)); break; case MessageCode.Server.Login: SoulseekClient.Waiter.Complete(new WaitKey(code), LoginResponse.FromByteArray(message)); break; case MessageCode.Server.RoomList: SoulseekClient.Waiter.Complete(new WaitKey(code), RoomList.FromByteArray(message)); break; case MessageCode.Server.PrivilegedUsers: SoulseekClient.Waiter.Complete(new WaitKey(code), PrivilegedUserList.FromByteArray(message)); break; case MessageCode.Server.NetInfo: var netInfo = NetInfo.FromByteArray(message); try { await SoulseekClient.DistributedConnectionManager.AddParentConnectionAsync(netInfo.Parents).ConfigureAwait(false); } catch (Exception ex) { Diagnostic.Debug($"Error handling NetInfo message: {ex.Message}"); } break; case MessageCode.Server.ConnectToPeer: ConnectToPeerResponse connectToPeerResponse = default; try { connectToPeerResponse = ConnectToPeerResponse.FromByteArray(message); if (connectToPeerResponse.Type == Constants.ConnectionType.Transfer) { // ensure that we are expecting at least one file from this user before we connect. the response // doesn't contain any other identifying information about the file. if (!SoulseekClient.Downloads.IsEmpty && SoulseekClient.Downloads.Values.Any(d => d.Username == connectToPeerResponse.Username)) { var(connection, remoteToken) = await SoulseekClient.PeerConnectionManager.GetTransferConnectionAsync(connectToPeerResponse).ConfigureAwait(false); var download = SoulseekClient.Downloads.Values.FirstOrDefault(v => v.RemoteToken == remoteToken && v.Username == connectToPeerResponse.Username); if (download != default(Transfer)) { SoulseekClient.Waiter.Complete(new WaitKey(Constants.WaitKey.IndirectTransfer, download.Username, download.Filename, download.RemoteToken), connection); } } else { throw new SoulseekClientException($"Unexpected transfer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPAddress}:{connectToPeerResponse.Port}); Ignored"); } } else if (connectToPeerResponse.Type == Constants.ConnectionType.Peer) { await SoulseekClient.PeerConnectionManager.GetOrAddMessageConnectionAsync(connectToPeerResponse).ConfigureAwait(false); } else if (connectToPeerResponse.Type == Constants.ConnectionType.Distributed) { await SoulseekClient.DistributedConnectionManager.AddChildConnectionAsync(connectToPeerResponse).ConfigureAwait(false); } else { throw new MessageException($"Unknown Connect To Peer connection type '{connectToPeerResponse.Type}'"); } } catch (Exception ex) { Diagnostic.Debug($"Error handling ConnectToPeer response from {connectToPeerResponse?.Username} ({connectToPeerResponse?.IPAddress}:{connectToPeerResponse.Port}): {ex.Message}"); } break; case MessageCode.Server.AddUser: var addUserResponse = AddUserResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, addUserResponse.Username), addUserResponse); break; case MessageCode.Server.GetStatus: var statsResponse = GetStatusResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, statsResponse.Username), statsResponse); UserStatusChanged?.Invoke(this, new UserStatusChangedEventArgs(statsResponse)); break; case MessageCode.Server.PrivateMessage: var pm = PrivateMessage.FromByteArray(message); PrivateMessageReceived?.Invoke(this, pm); if (SoulseekClient.Options.AutoAcknowledgePrivateMessages) { await SoulseekClient.AcknowledgePrivateMessageAsync(pm.Id, CancellationToken.None).ConfigureAwait(false); } break; case MessageCode.Server.GetPeerAddress: var peerAddressResponse = GetPeerAddressResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, peerAddressResponse.Username), peerAddressResponse); break; default: Diagnostic.Debug($"Unhandled server message: {code}; {message.Length} bytes"); break; } } catch (Exception ex) { Diagnostic.Warning($"Error handling server message: {code}; {ex.Message}", ex); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { try { dtcControlEvent.Reset(); Tracer.Debug("Prepare notification received for TX id: " + this.transactionId); BeforeEnd(); // Before sending the request to the broker, log the recovery bits, if // this fails we can't prepare and the TX should be rolled back. RecoveryLogger.LogRecoveryInfo(this.transactionId as XATransactionId, preparingEnlistment.RecoveryInformation()); // Inform the broker that work on the XA'sh TX Branch is complete. TransactionInfo info = new TransactionInfo(); info.ConnectionId = this.connection.ConnectionId; info.TransactionId = this.transactionId; info.Type = (int)TransactionType.End; this.connection.CheckConnected(); this.connection.SyncRequest(info); // Prepare the Transaction for commit. info.Type = (int)TransactionType.Prepare; IntegerResponse response = (IntegerResponse)this.connection.SyncRequest(info); if (response.Result == XA_READONLY) { Tracer.Debug("Transaction Prepare done and doesn't need a commit, TX id: " + this.transactionId); this.transactionId = null; this.currentEnlistment = null; // Read Only means there's nothing to recover because there was no // change on the broker. RecoveryLogger.LogRecovered(this.transactionId as XATransactionId); // if server responds that nothing needs to be done, then reply prepared // but clear the current state data so we appear done to the commit method. preparingEnlistment.Prepared(); // Done so commit won't be called. AfterCommit(); } else { Tracer.Debug("Transaction Prepare succeeded TX id: " + this.transactionId); // If work finished correctly, reply prepared preparingEnlistment.Prepared(); } } catch (Exception ex) { Tracer.DebugFormat("Transaction[{0}] Prepare failed with error: {1}", this.transactionId, ex.Message); AfterRollback(); preparingEnlistment.ForceRollback(); try { this.connection.OnException(ex); } catch (Exception error) { Tracer.Error(error.ToString()); } this.currentEnlistment = null; this.transactionId = null; } finally { this.dtcControlEvent.Set(); } }
/// <summary> /// Handles incoming messages. /// </summary> /// <param name="sender">The <see cref="IMessageConnection"/> instance from which the message originated.</param> /// <param name="message">The message.</param> public async void HandleMessageRead(object sender, byte[] message) { var code = new MessageReader <MessageCode.Server>(message).ReadCode(); if (code != MessageCode.Server.SearchRequest) { Diagnostic.Debug($"Server message received: {code}"); } try { switch (code) { case MessageCode.Server.ParentMinSpeed: case MessageCode.Server.ParentSpeedRatio: case MessageCode.Server.WishlistInterval: case MessageCode.Server.CheckPrivileges: SoulseekClient.Waiter.Complete(new WaitKey(code), IntegerResponse.FromByteArray <MessageCode.Server>(message)); break; case MessageCode.Server.NewPassword: var confirmedPassword = NewPassword.FromByteArray(message).Password; SoulseekClient.Waiter.Complete(new WaitKey(code), confirmedPassword); break; case MessageCode.Server.GlobalAdminMessage: var msg = GlobalMessageNotification.FromByteArray(message); GlobalMessageReceived?.Invoke(this, new GlobalMessageReceivedEventArgs(msg)); break; case MessageCode.Server.Ping: SoulseekClient.Waiter.Complete(new WaitKey(code)); break; case MessageCode.Server.Login: SoulseekClient.Waiter.Complete(new WaitKey(code), LoginResponse.FromByteArray(message)); break; case MessageCode.Server.RoomList: var roomList = RoomListResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code), roomList); RoomListReceived?.Invoke(this, new RoomListReceivedEventArgs(roomList)); break; case MessageCode.Server.PrivilegedUsers: var privilegedUserList = PrivilegedUserListNotification.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code), privilegedUserList); PrivilegedUserListReceived?.Invoke(this, new PrivilegedUserListReceivedEventArgs(privilegedUserList)); break; case MessageCode.Server.AddPrivilegedUser: PrivilegeNotificationReceived?.Invoke(this, new PrivilegeNotificationReceivedEventArgs(PrivilegedUserNotification.FromByteArray(message))); break; case MessageCode.Server.NotifyPrivileges: var pn = PrivilegeNotification.FromByteArray(message); PrivilegeNotificationReceived?.Invoke(this, new PrivilegeNotificationReceivedEventArgs(pn.Username, pn.Id)); if (SoulseekClient.Options.AutoAcknowledgePrivilegeNotifications) { await SoulseekClient.AcknowledgePrivilegeNotificationAsync(pn.Id, CancellationToken.None).ConfigureAwait(false); } break; case MessageCode.Server.UserPrivileges: var privilegeResponse = UserPrivilegeResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, privilegeResponse.Username), privilegeResponse.IsPrivileged); break; case MessageCode.Server.NetInfo: var netInfo = NetInfoNotification.FromByteArray(message); try { var parents = netInfo.Parents.Select(parent => (parent.Username, new IPEndPoint(parent.IPAddress, parent.Port))); await SoulseekClient.DistributedConnectionManager.AddParentConnectionAsync(parents).ConfigureAwait(false); } catch (Exception ex) { Diagnostic.Debug($"Error handling NetInfo message: {ex.Message}"); } break; case MessageCode.Server.ConnectToPeer: ConnectToPeerResponse connectToPeerResponse = default; try { connectToPeerResponse = ConnectToPeerResponse.FromByteArray(message); if (connectToPeerResponse.Type == Constants.ConnectionType.Transfer) { Diagnostic.Debug($"Received transfer ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}) for remote token {connectToPeerResponse.Token}"); // ensure that we are expecting at least one file from this user before we connect. the response // doesn't contain any other identifying information about the file. if (!SoulseekClient.Downloads.IsEmpty && SoulseekClient.Downloads.Values.Any(d => d.Username == connectToPeerResponse.Username)) { var(connection, remoteToken) = await SoulseekClient.PeerConnectionManager.GetTransferConnectionAsync(connectToPeerResponse).ConfigureAwait(false); var download = SoulseekClient.Downloads.Values.FirstOrDefault(v => v.RemoteToken == remoteToken && v.Username == connectToPeerResponse.Username); if (download != default(TransferInternal)) { Diagnostic.Debug($"Solicited inbound transfer connection to {download.Username} ({connection.IPEndPoint}) for token {download.Token} (remote: {download.RemoteToken}) established. (id: {connection.Id})"); SoulseekClient.Waiter.Complete(new WaitKey(Constants.WaitKey.IndirectTransfer, download.Username, download.Filename, download.RemoteToken), connection); } else { Diagnostic.Debug($"Transfer ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}) for remote token {connectToPeerResponse.Token} does not match any waiting downloads, discarding."); connection.Disconnect($"Unknown transfer"); } } else { throw new SoulseekClientException($"Unexpected transfer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}); Ignored"); } } else if (connectToPeerResponse.Type == Constants.ConnectionType.Peer) { Diagnostic.Debug($"Received message ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint})"); await SoulseekClient.PeerConnectionManager.GetOrAddMessageConnectionAsync(connectToPeerResponse).ConfigureAwait(false); } else if (connectToPeerResponse.Type == Constants.ConnectionType.Distributed) { Diagnostic.Debug($"Received distributed ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint})"); await SoulseekClient.DistributedConnectionManager.AddChildConnectionAsync(connectToPeerResponse).ConfigureAwait(false); } else { throw new MessageException($"Unknown Connect To Peer connection type '{connectToPeerResponse.Type}'"); } } catch (Exception ex) { Diagnostic.Debug($"Error handling ConnectToPeer response from {connectToPeerResponse?.Username} ({connectToPeerResponse?.IPEndPoint}): {ex.Message}"); } break; case MessageCode.Server.AddUser: var addUserResponse = AddUserResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, addUserResponse.Username), addUserResponse); break; case MessageCode.Server.GetStatus: var statsResponse = UserStatusResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, statsResponse.Username), statsResponse); UserStatusChanged?.Invoke(this, new UserStatusChangedEventArgs(statsResponse)); break; case MessageCode.Server.PrivateMessage: var pm = PrivateMessageNotification.FromByteArray(message); PrivateMessageReceived?.Invoke(this, new PrivateMessageReceivedEventArgs(pm)); if (SoulseekClient.Options.AutoAcknowledgePrivateMessages) { await SoulseekClient.AcknowledgePrivateMessageAsync(pm.Id, CancellationToken.None).ConfigureAwait(false); } break; case MessageCode.Server.GetPeerAddress: var peerAddressResponse = UserAddressResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, peerAddressResponse.Username), peerAddressResponse); break; case MessageCode.Server.JoinRoom: var roomData = RoomJoinResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, roomData.Name), roomData); break; case MessageCode.Server.LeaveRoom: var leaveRoomResponse = RoomLeaveResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, leaveRoomResponse.RoomName)); break; case MessageCode.Server.SayInChatRoom: var roomMessage = RoomMessageNotification.FromByteArray(message); RoomMessageReceived?.Invoke(this, new RoomMessageReceivedEventArgs(roomMessage)); break; case MessageCode.Server.UserJoinedRoom: var joinNotification = RoomJoinedNotification.FromByteArray(message); RoomJoined?.Invoke(this, new RoomJoinedEventArgs(joinNotification)); break; case MessageCode.Server.UserLeftRoom: var leftNotification = RoomLeftNotification.FromByteArray(message); RoomLeft?.Invoke(this, new RoomLeftEventArgs(leftNotification)); break; case MessageCode.Server.KickedFromServer: KickedFromServer?.Invoke(this, EventArgs.Empty); break; case MessageCode.Server.FileSearch: var searchRequest = ServerSearchRequest.FromByteArray(message); // sometimes (most of the time?) a room search will result in a request to ourselves (assuming we are // joined to it) if (searchRequest.Username == SoulseekClient.Username) { break; } SearchResponse searchResponse; if (SoulseekClient.Options.SearchResponseResolver == default) { break; } try { searchResponse = await SoulseekClient.Options.SearchResponseResolver(searchRequest.Username, searchRequest.Token, SearchQuery.FromText(searchRequest.Query)).ConfigureAwait(false); if (searchResponse != null && searchResponse.FileCount + searchResponse.LockedFileCount > 0) { var endpoint = await SoulseekClient.GetUserEndPointAsync(searchRequest.Username).ConfigureAwait(false); var peerConnection = await SoulseekClient.PeerConnectionManager.GetOrAddMessageConnectionAsync(searchRequest.Username, endpoint, CancellationToken.None).ConfigureAwait(false); await peerConnection.WriteAsync(searchResponse.ToByteArray()).ConfigureAwait(false); } } catch (Exception ex) { Diagnostic.Warning($"Error resolving search response for query '{searchRequest.Query}' requested by {searchRequest.Username} with token {searchRequest.Token}: {ex.Message}", ex); } break; // if we fail to connect to a distributed parent in a timely manner, the server will begin to send us distributed search requests directly. // forward these to the distributed message handler. case MessageCode.Server.SearchRequest: SoulseekClient.DistributedMessageHandler.HandleMessageRead(SoulseekClient.ServerConnection, message); break; default: Diagnostic.Debug($"Unhandled server message: {code}; {message.Length} bytes"); break; } } catch (Exception ex) { Diagnostic.Warning($"Error handling server message: {code}; {ex.Message}", ex); } }
/// <summary> /// Handles incoming messages. /// </summary> /// <param name="sender">The <see cref="IMessageConnection"/> instance from which the message originated.</param> /// <param name="message">The message.</param> public async void HandleMessageRead(object sender, byte[] message) { var code = new MessageReader <MessageCode.Server>(message).ReadCode(); if (code != MessageCode.Server.EmbeddedMessage) { Diagnostic.Debug($"Server message received: {code}"); } try { switch (code) { case MessageCode.Server.ParentMinSpeed: case MessageCode.Server.ParentSpeedRatio: case MessageCode.Server.WishlistInterval: case MessageCode.Server.CheckPrivileges: SoulseekClient.Waiter.Complete(new WaitKey(code), IntegerResponse.FromByteArray <MessageCode.Server>(message)); break; case MessageCode.Server.PrivateRoomAdded: PrivateRoomMembershipAdded?.Invoke(this, StringResponse.FromByteArray <MessageCode.Server>(message)); break; case MessageCode.Server.PrivateRoomRemoved: var privateRoomRemoved = StringResponse.FromByteArray <MessageCode.Server>(message); SoulseekClient.Waiter.Complete(new WaitKey(code, privateRoomRemoved)); PrivateRoomMembershipRemoved?.Invoke(this, privateRoomRemoved); break; case MessageCode.Server.PrivateRoomOperatorAdded: PrivateRoomModerationAdded?.Invoke(this, StringResponse.FromByteArray <MessageCode.Server>(message)); break; case MessageCode.Server.PrivateRoomOperatorRemoved: var privateRoomOperatorRemoved = StringResponse.FromByteArray <MessageCode.Server>(message); SoulseekClient.Waiter.Complete(new WaitKey(code, privateRoomOperatorRemoved)); PrivateRoomModerationRemoved?.Invoke(this, privateRoomOperatorRemoved); break; case MessageCode.Server.NewPassword: var confirmedPassword = NewPassword.FromByteArray(message).Password; SoulseekClient.Waiter.Complete(new WaitKey(code), confirmedPassword); break; case MessageCode.Server.PrivateRoomToggle: var acceptInvitations = PrivateRoomToggle.FromByteArray(message).AcceptInvitations; SoulseekClient.Waiter.Complete(new WaitKey(code), acceptInvitations); break; case MessageCode.Server.GlobalAdminMessage: var msg = GlobalMessageNotification.FromByteArray(message); GlobalMessageReceived?.Invoke(this, msg); break; case MessageCode.Server.Ping: SoulseekClient.Waiter.Complete(new WaitKey(code)); break; case MessageCode.Server.Login: SoulseekClient.Waiter.Complete(new WaitKey(code), LoginResponse.FromByteArray(message)); break; case MessageCode.Server.RoomList: var roomList = RoomListResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code), roomList); RoomListReceived?.Invoke(this, roomList); break; case MessageCode.Server.PrivateRoomOwned: var moderatedRoomInfo = PrivateRoomOwnedListNotification.FromByteArray(message); PrivateRoomModeratedUserListReceived?.Invoke(this, moderatedRoomInfo); break; case MessageCode.Server.PrivateRoomUsers: var roomInfo = PrivateRoomUserListNotification.FromByteArray(message); PrivateRoomUserListReceived?.Invoke(this, roomInfo); break; case MessageCode.Server.PrivilegedUsers: var privilegedUserList = PrivilegedUserListNotification.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code), privilegedUserList); PrivilegedUserListReceived?.Invoke(this, privilegedUserList); break; case MessageCode.Server.AddPrivilegedUser: PrivilegeNotificationReceived?.Invoke(this, new PrivilegeNotificationReceivedEventArgs(PrivilegedUserNotification.FromByteArray(message))); break; case MessageCode.Server.NotifyPrivileges: var pn = PrivilegeNotification.FromByteArray(message); PrivilegeNotificationReceived?.Invoke(this, new PrivilegeNotificationReceivedEventArgs(pn.Username, pn.Id)); if (SoulseekClient.Options.AutoAcknowledgePrivilegeNotifications) { await SoulseekClient.AcknowledgePrivilegeNotificationAsync(pn.Id, CancellationToken.None).ConfigureAwait(false); } break; case MessageCode.Server.UserPrivileges: var privilegeResponse = UserPrivilegeResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, privilegeResponse.Username), privilegeResponse.IsPrivileged); break; case MessageCode.Server.NetInfo: var netInfo = NetInfoNotification.FromByteArray(message); try { var parents = netInfo.Parents.Select(parent => (parent.Username, new IPEndPoint(parent.IPAddress, parent.Port))); await SoulseekClient.DistributedConnectionManager.AddParentConnectionAsync(parents).ConfigureAwait(false); } catch (Exception ex) { Diagnostic.Debug($"Error handling NetInfo message: {ex.Message}"); } break; case MessageCode.Server.CannotConnect: var cannotConnect = CannotConnect.FromByteArray(message); Diagnostic.Debug($"Received CannotConnect message for token {cannotConnect.Token}{(!string.IsNullOrEmpty(cannotConnect.Username) ? $" from user {cannotConnect.Username}" : string.Empty)}"); SoulseekClient.SearchResponder.TryDiscard(cannotConnect.Token); if (!string.IsNullOrEmpty(cannotConnect.Username)) { UserCannotConnect?.Invoke(this, new UserCannotConnectEventArgs(cannotConnect)); } break; case MessageCode.Server.CannotJoinRoom: var cannotJoinRoom = CannotJoinRoom.FromByteArray(message); SoulseekClient.Waiter.Throw( new WaitKey(MessageCode.Server.JoinRoom, cannotJoinRoom.RoomName), new RoomJoinForbiddenException($"The server rejected the request to join room {cannotJoinRoom.RoomName}")); break; case MessageCode.Server.ConnectToPeer: var connectToPeerResponse = ConnectToPeerResponse.FromByteArray(message); try { if (connectToPeerResponse.Type == Constants.ConnectionType.Transfer) { Diagnostic.Debug($"Received transfer ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}) for remote token {connectToPeerResponse.Token}"); // ensure that we are expecting at least one file from this user before we connect. the response // doesn't contain any other identifying information about the file. if (!SoulseekClient.Downloads.IsEmpty && SoulseekClient.Downloads.Values.Any(d => d.Username == connectToPeerResponse.Username)) { var(connection, remoteToken) = await SoulseekClient.PeerConnectionManager.GetTransferConnectionAsync(connectToPeerResponse).ConfigureAwait(false); var download = SoulseekClient.Downloads.Values.FirstOrDefault(v => v.RemoteToken == remoteToken && v.Username == connectToPeerResponse.Username); if (download != default(TransferInternal)) { Diagnostic.Debug($"Solicited inbound transfer connection to {download.Username} ({connection.IPEndPoint}) for token {download.Token} (remote: {download.RemoteToken}) established. (id: {connection.Id})"); SoulseekClient.Waiter.Complete(new WaitKey(Constants.WaitKey.IndirectTransfer, download.Username, download.Filename, download.RemoteToken), connection); } else { Diagnostic.Debug($"Transfer ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}) for remote token {connectToPeerResponse.Token} does not match any waiting downloads, discarding."); connection.Disconnect("Unknown transfer"); } } else { throw new SoulseekClientException($"Unexpected transfer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}); Ignored"); } } else if (connectToPeerResponse.Type == Constants.ConnectionType.Peer) { Diagnostic.Debug($"Received message ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint})"); await SoulseekClient.PeerConnectionManager.GetOrAddMessageConnectionAsync(connectToPeerResponse).ConfigureAwait(false); } else if (connectToPeerResponse.Type == Constants.ConnectionType.Distributed) { Diagnostic.Debug($"Received distributed ConnectToPeer request from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint})"); await SoulseekClient.DistributedConnectionManager.GetOrAddChildConnectionAsync(connectToPeerResponse).ConfigureAwait(false); } else { throw new MessageException($"Unknown Connect To Peer connection type '{connectToPeerResponse.Type}'"); } } catch (Exception ex) { Diagnostic.Debug($"Error handling ConnectToPeer response from {connectToPeerResponse.Username} ({connectToPeerResponse.IPEndPoint}): {ex.Message}"); } break; case MessageCode.Server.AddUser: var addUserResponse = AddUserResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, addUserResponse.Username), addUserResponse); break; case MessageCode.Server.GetStatus: var statsResponse = UserStatusResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, statsResponse.Username), statsResponse); UserStatusChanged?.Invoke(this, new UserStatusChangedEventArgs(statsResponse)); break; case MessageCode.Server.PrivateMessage: var pm = PrivateMessageNotification.FromByteArray(message); PrivateMessageReceived?.Invoke(this, new PrivateMessageReceivedEventArgs(pm)); if (SoulseekClient.Options.AutoAcknowledgePrivateMessages) { await SoulseekClient.AcknowledgePrivateMessageAsync(pm.Id, CancellationToken.None).ConfigureAwait(false); } break; case MessageCode.Server.GetPeerAddress: var peerAddressResponse = UserAddressResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, peerAddressResponse.Username), peerAddressResponse); break; case MessageCode.Server.JoinRoom: var roomData = JoinRoomResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, roomData.Name), roomData); break; case MessageCode.Server.LeaveRoom: var leaveRoomResponse = LeaveRoomResponse.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, leaveRoomResponse.RoomName)); break; case MessageCode.Server.SayInChatRoom: var roomMessage = RoomMessageNotification.FromByteArray(message); RoomMessageReceived?.Invoke(this, new RoomMessageReceivedEventArgs(roomMessage)); break; case MessageCode.Server.PublicChat: var publicChatMessage = PublicChatMessageNotification.FromByteArray(message); PublicChatMessageReceived?.Invoke(this, new PublicChatMessageReceivedEventArgs(publicChatMessage)); break; case MessageCode.Server.UserJoinedRoom: var joinNotification = UserJoinedRoomNotification.FromByteArray(message); RoomJoined?.Invoke(this, new RoomJoinedEventArgs(joinNotification)); break; case MessageCode.Server.UserLeftRoom: var leftNotification = UserLeftRoomNotification.FromByteArray(message); RoomLeft?.Invoke(this, new RoomLeftEventArgs(leftNotification)); break; case MessageCode.Server.RoomTickers: var roomTickers = RoomTickerListNotification.FromByteArray(message); RoomTickerListReceived?.Invoke(this, new RoomTickerListReceivedEventArgs(roomTickers)); break; case MessageCode.Server.RoomTickerAdd: var roomTickerAdded = RoomTickerAddedNotification.FromByteArray(message); RoomTickerAdded?.Invoke(this, new RoomTickerAddedEventArgs(roomTickerAdded.RoomName, roomTickerAdded.Ticker)); break; case MessageCode.Server.RoomTickerRemove: var roomTickerRemoved = RoomTickerRemovedNotification.FromByteArray(message); RoomTickerRemoved?.Invoke(this, new RoomTickerRemovedEventArgs(roomTickerRemoved.RoomName, roomTickerRemoved.Username)); break; case MessageCode.Server.PrivateRoomAddUser: var privateRoomAddUserResponse = PrivateRoomAddUser.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, privateRoomAddUserResponse.RoomName, privateRoomAddUserResponse.Username)); break; case MessageCode.Server.PrivateRoomRemoveUser: var privateRoomRemoveUserResponse = PrivateRoomRemoveUser.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, privateRoomRemoveUserResponse.RoomName, privateRoomRemoveUserResponse.Username)); break; case MessageCode.Server.PrivateRoomAddOperator: var privateRoomAddOperatorResponse = PrivateRoomAddOperator.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, privateRoomAddOperatorResponse.RoomName, privateRoomAddOperatorResponse.Username)); break; case MessageCode.Server.PrivateRoomRemoveOperator: var privateRoomRemoveOperatorResponse = PrivateRoomRemoveOperator.FromByteArray(message); SoulseekClient.Waiter.Complete(new WaitKey(code, privateRoomRemoveOperatorResponse.RoomName, privateRoomRemoveOperatorResponse.Username)); break; case MessageCode.Server.KickedFromServer: KickedFromServer?.Invoke(this, EventArgs.Empty); break; case MessageCode.Server.FileSearch: var searchRequest = ServerSearchRequest.FromByteArray(message); // sometimes (most of the time?) a room search will result in a request to ourselves (assuming we are // joined to it) if (searchRequest.Username == SoulseekClient.Username) { break; } await SoulseekClient.SearchResponder.TryRespondAsync(searchRequest.Username, searchRequest.Token, searchRequest.Query).ConfigureAwait(false); break; case MessageCode.Server.EmbeddedMessage: SoulseekClient.DistributedMessageHandler.HandleEmbeddedMessage(message); break; default: Diagnostic.Debug($"Unhandled server message: {code}; {message.Length} bytes"); break; } } catch (Exception ex) { Diagnostic.Warning($"Error handling server message: {code}; {ex.Message}", ex); } }
public async Task PrepareAsync(PreparingEnlistment preparingEnlistment) { using (await this.syncObject.LockAsync().Await()) { this.netTxState = TxState.Pending; try { Tracer.Debug("Prepare notification received for TX id: " + this.TransactionId); await BeforeEndAsync().Await(); // Before sending the request to the broker, log the recovery bits, if // this fails we can't prepare and the TX should be rolled back. RecoveryLogger.LogRecoveryInfo(this.TransactionId as XATransactionId, preparingEnlistment.RecoveryInformation()); // Inform the broker that work on the XA'sh TX Branch is complete. TransactionInfo info = new TransactionInfo(); info.ConnectionId = this.connection.ConnectionId; info.TransactionId = this.TransactionId; info.Type = (int)TransactionType.End; await this.connection.CheckConnectedAsync().Await(); await this.connection.SyncRequestAsync((TransactionInfo)info.Clone()).Await(); // Prepare the Transaction for commit. info.Type = (int)TransactionType.Prepare; IntegerResponse response = (IntegerResponse)await this.connection.SyncRequestAsync(info).Await(); if (response.Result == XA_READONLY) { Tracer.Debug("Transaction Prepare done and doesn't need a commit, TX id: " + this.TransactionId); this.TransactionId = null; this.currentEnlistment = null; // Read Only means there's nothing to recover because there was no // change on the broker. RecoveryLogger.LogRecovered(this.TransactionId as XATransactionId); // if server responds that nothing needs to be done, then reply done. // otherwise the DTC will call Commit or Rollback but another transaction // can already be in progress and this one would be commited or rolled back // immediately. preparingEnlistment.Done(); // Done so commit won't be called. AfterCommit(); // A Read-Only TX is considered closed at this point, DTC won't call us again. this.dtcControlEvent.Set(); } else { Tracer.Debug("Transaction Prepare succeeded TX id: " + this.TransactionId); // If work finished correctly, reply prepared preparingEnlistment.Prepared(); } } catch (Exception ex) { Tracer.DebugFormat("Transaction[{0}] Prepare failed with error: {1}", this.TransactionId, ex.Message); AfterRollback(); preparingEnlistment.ForceRollback(); try { this.connection.OnAsyncException(ex); } catch (Exception error) { Tracer.Error(error.ToString()); } this.currentEnlistment = null; this.TransactionId = null; this.netTxState = TxState.None; this.dtcControlEvent.Set(); } } }