Exemplo n.º 1
0
        private void ThreadedReceiver_ServerDataReceived(object sender, AsyncCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                ReceiveData data = e.UserState as ReceiveData;
                if (data != null)
                {
                    MessageData messageData = data.clientData;
                    Client      client      = ClientStore.FindClient(data.clientHandle);
                    if (messageData != null && messageData.id > 0)
                    {
                        Console.WriteLine("received Message Type: {0}", messageData.id);
                        if (client != null)
                        {
                            Console.WriteLine("\tFrom Client: {0}", data.clientHandle);

                            // It's a string message, so just print it out for now.
                            Console.WriteLine("[{0}]: {1} ", messageData.name, ((messageData.message is string) ? messageData.message : ((messageData.message as byte[]).Length + " bytes")));
                        }

                        if (MessageFactory != null)
                        {
                            IMessageImpl msgImpl = MessageFactory.MakeMessageImpl(messageData.id, client.ClientHandle);

                            if (msgImpl != default(IMessageImpl))
                            {
                                messageHandler.Handle(client, messageData, msgImpl, this);
                            }
                        }
                    }
                }
            }
        }
        public void SendLoop(object arg)
        {
            Client client = arg as Client;

            if ((client != null) && (client.ClientSocket != null))
            {
                while (!looper.LoopDone)
                {
                    try
                    {
                        var eventData = GetDataAsync.GetMessageDataAsync(client.DataGetter, client.ClientHandle);

                        if (eventData != null)
                        {
                            //if ((eventData.Result != null) && (eventData.Result.id > 0) && (eventData.Result.message != null))
                            if (eventData.Result != null)
                            {
                                byte[] buffer = ClientData <MessageData> .SerializeToByteArray <MessageData>(eventData.Result);

                                var res = TcpLibExtensions.SendBufferAsync(client.ClientSocket, buffer, 0, buffer.Length, SocketFlags.None, client.CancelSource.Token);
                                if (res.IsFaulted || (res.Result == null) || res.Result.Failure)
                                {
                                    // Just close the socket.  Look into trying to reconnect
                                    Console.WriteLine("Send Fault. Closing socket {0} to client.", client.ClientSocket.Handle);
                                    //ClientStore.RemoveClient((long)client.ClientSocket.Handle);
                                }
                                else if (eventData.Result.exitCmd)
                                {
                                    Console.WriteLine("Exit Command Received");
                                    ClientStore.RemoveClient((long)client.ClientSocket.Handle);
                                    client.Stop();
                                }
                                else
                                {
                                    // Data sent.  Clear out buffer
                                    System.Diagnostics.Debug.WriteLine("Client {0} Sent Data.", client.ClientSocket.Handle);
                                    client.ClearData();
                                }
                            }
                            else
                            {
                                Console.WriteLine("Client: {0} -- NULL Message Result", client.ClientHandle);
                            }
                        }
                    }
                    catch (TaskCanceledException tc)
                    {
                        looper.LoopDone = true;
                        System.Diagnostics.Debug.WriteLine("Send Task Cancelled: " + tc.Message);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("Send Exception: " + e.Message);
                    }
                }
                Console.WriteLine("Send Loop Exiting...");
            }
        }
        public void ListenLoop(object arg)
        {
            ClientStore clients = arg as ClientStore;

            if (clients != null)
            {
                while (!looper.LoopDone)
                {
                    try
                    {
                        var res = ServerListenAsync(useLocalhost);
                        if (res.IsFaulted || (res.Result == null))
                        {
                            Console.WriteLine("Problem with connection.");
                        }
                        else
                        {
                            Console.WriteLine("Accepted Client Connection on port: {0}", CliServDefaults.DfltPort);
                            Client client = new Client(res.Result, CliServDefaults.BufferSize, dataGetter);
                            try
                            {
                                // Start the service loops
                                client.Start();
                                ClientStore.AddClient(client, client.ClientHandle);
                                OnClientConnect?.Invoke(client);
                            }
                            catch (Exception e)
                            {
                                Console.WriteLine("Client Add to List Exception: {0}", e.Message);
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.Message);
                    }
                }
                if (_listenSocket.Connected)
                {
                    _listenSocket.Shutdown(SocketShutdown.Both);
                    _listenSocket.Close();
                }
                Console.WriteLine("Listener Done.");
            }
        }
        /// <summary>
        /// The work done on the receive loop.  It assumes we are receiving MessageData types unless
        /// a MessageData received indicates a file to be received.  Then it switches over to receiving
        /// byte[].
        /// </summary>
        /// <param name="client">The client data is received from</param>
        private void ClientReceive(Client client)
        {
            if ((client == null) || (client.ClientSocket == null))
            {
                return;
            }

            ReceiveData rcvData = new ReceiveData();

            try
            {
                client.ClearData();

                var res = TcpLibExtensions.ReceiveAsync(client.ClientSocket, client.ClientData(), 0, client.DataSize, SocketFlags.None, client.CancelSource.Token);
                if (res.IsFaulted || (res.Result == null) || res.Result.Failure)
                {
                    // Just close the socket.  Look into trying to reconnect
                    Console.WriteLine("Receive Fault. Closing socket {0} to client.", client.ClientSocket.Handle);
                    ClientStore.RemoveClient((long)client.ClientSocket.Handle);
                }
                else
                {
                    System.Diagnostics.Debug.WriteLine("Receiving Data From Client: {0}", client.ClientSocket.Handle);
                    try
                    {
                        MessageData value = null;
                        if (receivingFile)
                        {
                            value              = fileMsg;
                            value.message      = client.ClientData();
                            value.length       = res.Result.Value;
                            rcvData.clientData = fileMsg;
                            totalRcv          += res.Result.Value;
                            System.Diagnostics.Debug.WriteLine("Received: Size:[{0}] - [{1}] out of [{2}]", res.Result.Value, totalRcv, fileSize);
                        }
                        else
                        {
                            value = ClientData <MessageData> .DeserializeFromByteArray <MessageData>(client.ClientData());

                            rcvData.clientData = value;
                        }
                        rcvData.clientHandle = (long)client.ClientSocket.Handle;

                        if (value != null)
                        {
                            // This indicates a response from the server to a client of which there could be many
                            if (value.response)
                            {
                                // Client received
                                OnClientDataReceived(new AsyncCompletedEventArgs(null, false, rcvData));
                            }
                            else
                            {
                                if (rcvData.clientData.id == 100)
                                {
                                    if (!receivingFile)
                                    {
                                        receivingFile    = true;
                                        fileSize         = rcvData.clientData.length;
                                        fileMsg.handle   = rcvData.clientData.handle;
                                        fileMsg.id       = rcvData.clientData.id;
                                        fileMsg.name     = rcvData.clientData.name;
                                        fileMsg.response = rcvData.clientData.response;
                                    }
                                    else if (totalRcv >= fileSize)
                                    {
                                        receivingFile = false;
                                        totalRcv      = 0;
                                        Console.WriteLine("Received all file.");
                                    }
                                }
                                // Server received
                                OnServerDataReceived(new AsyncCompletedEventArgs(null, false, rcvData));
                            }
                        }
                        else
                        {
                            // Send null message to client and server so they can detect disconnection
                            OnClientDataReceived(new AsyncCompletedEventArgs(null, false, rcvData));
                            OnServerDataReceived(new AsyncCompletedEventArgs(null, false, rcvData));
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.Message);
                    }
                }
            }
            catch (TaskCanceledException tc)
            {
                looper.LoopDone = true;
                System.Diagnostics.Debug.WriteLine("receive Task Cancelled: " + tc.Message);
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine("Receive Exception: " + ex.Message);
            }
        }