public override void Cancel()
            {
                IMessage msg;

                switch (State)
                {
                case FileTransferState.Success:
                case FileTransferState.Failure:
                case FileTransferState.Cancelled:
                    return;

                case FileTransferState.Waiting:
                case FileTransferState.Working:
                default:
                    msg = new CsFileTransferInterruption
                    {
                        SessionId = Id,
                        Token     = Token,
                        Int       = FileTransferInterruption.Cancel
                    };
                    break;
                }
                State = FileTransferState.Cancelled;
                Delete();
                Owner.client.Send(msg);
                Owner.OnTransferStateChanged(this);
            }
Exemple #2
0
        private void OnCsFileTransferInterruption(CsFileTransferInterruption msg, ClientId id)
        {
            var sender             = clients[id];
            FileTransferSession ft = null;

            if (msg.SessionId != FileTransferId.InvalidId)
            {
                ft = ftsContainer.GetSessionById(msg.SessionId);
            }
            else // client is sender and doesn't have sid yet
            {
                var senderSessions = ftsContainer.GetUserSessions(sender.Login);
                if (senderSessions != null)
                {
                    foreach (var sid in senderSessions)
                    {
                        var s = ftsContainer.GetSessionById(sid);
                        if (s.Token == msg.Token && s.Sender == sender.Login)
                        {
                            ft = s;
                            break;
                        }
                    }
                }
                if (ft == null)
                {
                    Root.Log(LogLevel.Warning, "Server: ignoring file transfer interruption from client {0} " +
                             "- session not found", sender.Login);
                    return;
                }
            }
            string           oppUsername = sender.Login == ft.Sender ? ft.Receiver : ft.Sender;
            SocketClientBase oppClient;

            if (!nameToClient.TryGetValue(oppUsername, out oppClient))
            {
                Root.Log(LogLevel.Warning, "Server: client {0} attempted to send file transfer data " +
                         "to disconnected client {1}", ft.Sender, ft.Receiver);
                // XXX: suspend session (cl is offline)
                return;
            }
            msg.SessionId = ft.Id;
            switch (msg.Int)
            {
            case FileTransferInterruption.Cancel:
            default:
                ft.State = FileTransferState.Cancelled;
                ftsContainer.DeleteSession(ft.Id);
                break;
            }
            if (!SendTo(oppClient.Id, msg))
            {
                // XXX: suspend file transfer session
            }
        }
        private void OnCsFileTransferInterruption(CsFileTransferInterruption msg)
        {
            FileTransferBase ft;

            if (!assignedFts.TryGetValue(msg.SessionId, out ft))
            {
                Root.Log(LogLevel.Error, "FileTransferManager: session not found [sid={0}]", msg.SessionId);
                return;
            }
            switch (msg.Int)
            {
            case FileTransferInterruption.Cancel:
            default:
                ft.State = FileTransferState.Cancelled;
                ft.Delete();
                break;
            }
            OnTransferStateChanged(ft);
        }
Exemple #4
0
        public void SaveLoadCsFileTransferInterruption()
        {
            // arrange
            const FileTransferInterruption refInt = FileTransferInterruption.Cancel;
            var         refSid   = new FileTransferId(81289);
            const ulong refToken = 120982;
            var         msg      = new CsFileTransferInterruption
            {
                Int       = refInt,
                SessionId = refSid,
                Token     = refToken,
            };

            // act
            MultiprotocolSaveLoad(msg, () =>
            {
                // assert
                Assert.AreEqual(msg.Int, refInt);
                Assert.AreEqual(msg.SessionId, refSid);
                Assert.AreEqual(msg.Token, refToken);
            });
        }