Exemple #1
0
 public void OutputException(Exception ex)
 {
     //Discarded
     Console.WriteLine(expectedSide.ToString() + " -> " + ex.ToString());
 }
Exemple #2
0
        public void StoreCommands(NetworkStream providedStream, bool dontCreateNetworkStream = false)
        {
            var binaryFormatter = new BinaryFormatter();

            TcpListener   server        = null;
            Socket        socket        = null;
            NetworkStream networkStream = null;

            if (providedStream != null)
            {
                networkStream = providedStream;
            }

            try
            {
                if (networkStream == null && !dontCreateNetworkStream)
                {
                    server = new TcpListener(IPAddress.Any, port);
                    server.Start();
                    socket        = KillableAcceptSocket(server);
                    networkStream = new NetworkStream(socket);
                    server.Stop();
                }

                networkStream.ReadTimeout  = DefaultNetworkStreamTimeout;
                networkStream.WriteTimeout = DefaultNetworkStreamTimeout;

                if (side == NetworkSide.CLIENT)
                {
                    SendCommand(new RTC_Command(CommandType.HI), false, true);
                }

                while (true)
                {
                    if (networkStream != null && networkStream.DataAvailable)
                    {
                        RTC_Command cmd;

                        try
                        {
                            cmd = (RTC_Command)binaryFormatter.Deserialize(networkStream);
                        }
                        catch (Exception ex)
                        {
                            throw ex;
                        }

                        if (cmd != null)
                        {
                            if (cmd.Type == CommandType.RETURNVALUE)
                            {
                                ReturnWatch.SyncReturns.Add((Guid)cmd.requestGuid, cmd.objectValue);
                            }
                            else
                            {
                                CommandQueue.AddLast(cmd);
                            }
                        }
                    }

                    while (PeerCommandQueue.Count > 0)
                    {
                        RTC_Command backCmd;

                        lock (CommandQueueLock)
                        {
                            backCmd = PeerCommandQueue.First.Value;
                            PeerCommandQueue.RemoveFirst();
                        }

                        try
                        {
                            binaryFormatter.Serialize(networkStream, backCmd);
                        }
                        catch (Exception ex)
                        {
                            throw ex;
                        }

                        if (backCmd.Type == CommandType.BYE)
                        {
                            CommandQueue.AddFirst(new RTC_Command(CommandType.SAIDBYE));
                            PeerCommandQueue.Clear();
                            throw new Exception("SAIDBYE");
                        }

                        if (side == NetworkSide.DISCONNECTED || side == NetworkSide.CONNECTIONLOST)
                        {
                            if (side == NetworkSide.DISCONNECTED)
                            {
                                CommandQueue.Clear();
                                PeerCommandQueue.Clear();
                            }

                            throw new Exception(side.ToString());
                        }
                    }

                    Thread.Sleep(5);
                }
            }
            catch (Exception ex)
            {
                OutputException(ex);

                if (side == NetworkSide.CLIENT || side == NetworkSide.SERVER)
                {
                    side = NetworkSide.CONNECTIONLOST;
                }
            }
            finally
            {
                if (networkStream != null)
                {
                    try
                    {
                        networkStream.Close();
                        networkStream.Dispose();
                    }
                    catch (Exception ex2) { OutputException(ex2); }
                }

                if (socket != null)
                {
                    //socket.Close();
                    try
                    {
                        socket.Shutdown(SocketShutdown.Both);
                        socket.Dispose();
                    }
                    catch (Exception ex2) { OutputException(ex2); }
                }

                if (server != null)
                {
                    try
                    {
                        server.Stop();
                    }
                    catch (Exception ex2) { OutputException(ex2); }
                }

                isStreamReadingThreadAlive = false;
            }
        }