Esempio n. 1
0
        /// <summary>
        /// Requests a file access token from the host.
        /// The file access token allows this client to access any files within the
        /// current dragdrop or clipboard operation. The token returned from this method
        /// should be used when requesting to read from the remote filestream along with the GUID
        /// of the file that you want to read.
        /// </summary>
        /// <exception cref="RemoteFileStreamReadFailedException"></exception>
        /// <exception cref="InvalidNetworkResponseException"></exception>"
        /// <exception cref="RequestTimedOutException"></exception>
        /// <param name="fileGroupId">The operation ID of the files to access</param>
        /// <returns></returns>
        public async Task <Guid> RequestFileTokenAsync(Guid fileGroupId)
        {
            ISLogger.Write("Sending token request");
            NetworkMessage response = await SendRequestAsync(new RequestGroupTokenMessage(fileGroupId));

            ISLogger.Write("Server responded to token request!");

            switch (response.Type)
            {
            case MessageType.RequestFileGroupTokenReponse:
                RequestGroupTokenResponseMessage resp = response as RequestGroupTokenResponseMessage;
                return(resp.Token);

            case MessageType.RemoteFileError:
                FileErrorMessage err = response as FileErrorMessage;
                ISLogger.Write("File token request returned error: " + err.ErrorMessage);
                return(Guid.Empty);

                break;

            default:
                ISLogger.Write("Debug: Server sent unexpected reply when requesting file access token");
                return(Guid.Empty);
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Sends a request to read a remote filestream from the host and
        /// waits for a response message.
        /// </summary>
        ///<exception cref="RemoteFileStreamReadFailedException"></exception>
        /// <exception cref="InvalidNetworkResponseException"></exception>"
        /// <exception cref="RequestTimedOutException"></exception>
        /// <param name="token">The access token used to access the filestream</param>
        /// <param name="file">The Guid associated with the file</param>
        /// <param name="readLen">Ammount of bytes to read</param>
        /// <returns></returns>
        public async Task <byte[]> RequestReadStreamAsync(Guid token, Guid file, int readLen)
        {
            NetworkMessage response = await SendRequestAsync(new FileStreamReadRequestMessage(token, file, readLen));

            switch (response.Type)
            {
            case MessageType.FileStreamReadResponse:
                FileStreamReadResponseMessage resp = response as FileStreamReadResponseMessage;
                return(resp.ReadData);

            case MessageType.RemoteFileError:
                FileErrorMessage errMsg = response as FileErrorMessage;
                throw new RemoteFileStreamReadFailedException(errMsg.ErrorMessage);

            default:
                throw new InvalidNetworkResponseException("Server responded with unexpected message type " + response.Type);
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Se gatilla cuando se recibe un mensaje
        /// </summary>
        /// <param name="message">El mensaje recibido</param>
        public void proccessMessage(Message message)
        {
            switch (message.Type)
            {
            case SubProtocol.FileTransfer.Types.FILEREQUESTMESSAGE:
            {
                FileRequestMessage fileRequestMessage = (FileRequestMessage)message;
                FileInformation    fileInformation    = fileData.FileList.getFileInformation(fileRequestMessage.FileId);
                if (fileInformation != null)
                {
                    FileMessageSender fileMessageSender = new FileMessageSender(fileRequestMessage.SenderNetUser, fileRequestMessage.FileHandlerId, sendMessageDelegate, fileInformation, fileData);
                    lock (fileMessageHandlerLock)
                    {
                        if (!activeUploads.Contains(fileMessageSender.Id))
                        {
                            if (fileMessageUploadQueue.put(fileMessageSender))
                            {
                                controlFileHandler.uploadFileQueued(fileRequestMessage.SenderNetUser, fileMessageSender.Id.ToString(), fileInformation.Name);
                            }
                        }
                    }
                }
                else
                {
                    FileErrorMessage fileErrorMessage = new FileErrorMessage(fileRequestMessage.SenderNetUser, fileRequestMessage.FileHandlerId);
                    sendMessageEvent(fileErrorMessage);
                }
                break;
            }

            case SubProtocol.FileTransfer.Types.FILEERRORMESSAGES:
            {
                FileErrorMessage fileErrorMessage = (FileErrorMessage)message;
                lock (fileMessageHandlerLock)
                {
                    if (activeUploads.Contains(fileErrorMessage.FileHandlerId))
                    {
                        FileMessageHandler fileMessageHandler = (FileMessageHandler)activeUploads[fileErrorMessage.FileHandlerId];
                        controlFileHandler.uploadFileFailed(fileMessageHandler.Id.ToString());
                        fileMessageHandler.close();
                        activeUploads.Remove(fileMessageHandler.Id);
                    }
                    else if (activeDownloads.Contains(fileErrorMessage.FileHandlerId))
                    {
                        FileMessageHandler fileMessageHandler = (FileMessageHandler)activeDownloads[fileErrorMessage.FileHandlerId];
                        controlFileHandler.downloadFileFailed(fileMessageHandler.Id.ToString());
                        fileMessageHandler.close();
                        activeDownloads.Remove(fileMessageHandler.Id);
                    }
                }
                break;
            }

            case SubProtocol.FileTransfer.Types.FILEPARTMESSAGE:
            {
                FilePartMessage filePartMessage = (FilePartMessage)message;
                lock (fileMessageHandlerLock)
                {
                    if (activeDownloads.Contains(filePartMessage.FileHandlerId))
                    {
                        FileMessageHandler fileMessageHandler = (FileMessageHandler)activeDownloads[filePartMessage.FileHandlerId];
                        fileMessageHandler.attendMessage(filePartMessage);
                        fileMessageHandler.waitUp(fileData.FileRiseUp);
                    }
                    else
                    {
                        FileErrorMessage fileErrorMessage = new FileErrorMessage(filePartMessage.SenderNetUser, filePartMessage.FileHandlerId);
                        sendMessageEvent(fileErrorMessage);
                    }
                }
                break;
            }

            case SubProtocol.FileTransfer.Types.FILEWAITMESSAGE:
            {
                FileWaitMessage fileWaitMessage = (FileWaitMessage)message;
                lock (fileMessageHandlerLock)
                {
                    if (activeDownloads.Contains(fileWaitMessage.FileHandlerId))
                    {
                        FileMessageHandler fileMessageHandler = (FileMessageHandler)activeDownloads[fileWaitMessage.FileHandlerId];
                        fileMessageHandler.waitUp(fileData.FileRiseUp);
                    }
                    else if (activeUploads.Contains(fileWaitMessage.FileHandlerId))
                    {
                        FileMessageHandler fileMessageHandler = (FileMessageHandler)activeUploads[fileWaitMessage.FileHandlerId];
                        fileMessageHandler.waitUp(fileData.FileRiseUp);
                    }
                    else
                    {
                        if (!fileMessageDownloadQueue.contains(fileWaitMessage.FileHandlerId) && !fileMessageUploadQueue.contains(fileWaitMessage.FileHandlerId))
                        {
                            FileErrorMessage fileErrorMessage = new FileErrorMessage(fileWaitMessage.SenderNetUser, fileWaitMessage.FileHandlerId);
                            sendMessageEvent(fileErrorMessage);
                        }
                    }
                }
                break;
            }

            case SubProtocol.FileTransfer.Types.FILECOMPLETEMESSAGE:
            {
                FileCompleteMessage fileCompleteMessage = (FileCompleteMessage)message;
                lock (fileMessageHandlerLock)
                {
                    if (activeUploads.Contains(fileCompleteMessage.FileHandlerId))
                    {
                        FileMessageHandler fileMessageHandler = (FileMessageHandler)activeUploads[fileCompleteMessage.FileHandlerId];
                        fileMessageHandler.State = FileMessageHandlerState.COMPLETED;
                    }
                }
                break;
            }

            case SubProtocol.FileTransfer.Types.FILELISTREQUESTMESSAGE:
            {
                FileListRequestMessage fileListRequestMessage = (FileListRequestMessage)message;
                FileListMessage        fileListMessage        = new FileListMessage(fileListRequestMessage.SenderNetUser, fileData.FileList);
                sendMessageEvent(fileListMessage);
                break;
            }

            case SubProtocol.FileTransfer.Types.FILELISTMESSAGE:
            {
                FileListMessage fileListMessage = (FileListMessage)message;
                controlFileListHandler.addFileList(fileListMessage.SenderNetUser, fileListMessage.FileList);
                break;
            }
            }
        }
Esempio n. 4
0
 private void SetAlertMessage(FileErrorMessage message)
 {
     AlertBoxMessage = message.Message;
     AlertBoxVisible = true;
 }
Esempio n. 5
0
        private void OnError(object sender, ErrorEventArgs e)
        {
            var message = new FileErrorMessage(_fileName, e.GetException().Message);

            _tailActor.Tell(message, ActorRefs.NoSender);
        }