Esempio n. 1
0
        public void TestTokenMessage()
        {
            TokenMessage msg = new TokenMessage();
            msg.EncodeHiddenComm("A", "B");
            TokenMessage msgTwo = new TokenMessage();

            msgTwo.Decode(msg.ToSend);
            CompareTokenMessages(msg, msgTwo);

            msg.EncodeMessage("C", "D", "hello!! :D |");
            msgTwo.Decode(msg.ToSend);
            CompareTokenMessages(msg, msgTwo);
        }
Esempio n. 2
0
        /// <summary>
        /// Tokens the sending.
        /// </summary>
        private void TokenSending()
        {
            int toSendCount = 0;
            char[] sep = { ',' };

            NetworkStream stream = this.client.GetStream();

            lock (ToSend)
            {
                toSendCount = ToSend.Count;
            }

            try
            {
                while (toSendCount > 0)
                {
                    while (!this.hasToken)
                    {
                        try
                        {
                            Thread.Sleep(Timeout.Infinite);
                        }
                        catch(ThreadAbortException)
                        {
                            throw;
                        }
                        catch
                        {
                            ;
                        }

                        if (!this.hasToken)
                        {
                            Console.WriteLine("Sending for node {0} received an interrupt when it wasn't supposed to.", parentNode.Name);
                        }
                    }

                    String msgToSend = toSend.Peek();
                    String[] info = msgToSend.Split(sep, 2);
                    TokenMessage msg = new TokenMessage();
                    msg.EncodeMessage(this.parentNode.Name, info[0], info[1]);

                    if (this.parentNode.GetRandomNum() < GlobalConst.errorPerc)
                    {
                        msg.ToSend[4] = 0;
                    }

                    UseDelegate(stream, msg);

                    //ASSUMING NO ERRORS. Need to update once errors have been put in.
                    try
                    {
                        Thread.Sleep(GlobalConst.TokenTimer * 1000);
                        continue;
                    }
                    catch(ThreadAbortException)
                    {
                        throw;
                    }
                    catch
                    {
                        ;
                    }

                    lock (ToSend)
                    {
                        toSendCount = this.toSend.Count;
                    }
                }

                this.doneSending = true;
            }
            catch (ThreadAbortException)
            {

            }
        }