| // $Id$ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| using System; |
| using System.Net; |
| using System.Net.Sockets; |
| using System.Threading; |
| using Org.Apache.Etch.Bindings.Csharp.Util; |
| using NUnit.Framework; |
| using TcpListener=Org.Apache.Etch.Bindings.Csharp.Util.TcpListener; |
| |
| namespace Org.Apache.Etch.Bindings.Csharp.Transport |
| { |
| [TestFixture] |
| public class TestTcpConnection |
| { |
| public static MyListener lh = new MyListener(); |
| public static Connection<SessionListener<Socket>> l; |
| public TcpConnection c; |
| private const int TIMEOUT = 4000; |
| private static int port; |
| |
| [TestFixtureSetUp] |
| public void StartListener() |
| { |
| Console.WriteLine(); |
| Console.Write( "TestTCPConnection" ); |
| |
| l = new TcpListener( "tcp:", null ); |
| l.SetSession(lh); |
| l.Start(); |
| l.WaitUp( TIMEOUT ); |
| port = ( ( IPEndPoint ) l.LocalAddress() ).Port; |
| //Console.WriteLine( " port = " + port ); |
| } |
| |
| [TestFixtureTearDown] |
| public void StopListener() |
| { |
| l.Stop(); |
| l.WaitDown( TIMEOUT ); |
| } |
| |
| #region Constructor tests |
| |
| [Test] |
| [ExpectedException(typeof(ArgumentNullException))] |
| public void Constructor1() |
| { |
| new TcpConnection( null, "tcp:", null ); |
| } |
| |
| [TearDown] |
| public void SleepAWhile() |
| { |
| Thread.Sleep( 1000 ); |
| } |
| |
| [Test] |
| public void Constructor2() |
| { |
| IPEndPoint ipe = new IPEndPoint( IPAddress.Parse( "127.0.0.1" ), port ); |
| Socket s = new Socket( ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp ); |
| s.Connect( ipe ); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null, TIMEOUT, null ); |
| |
| TcpConnection c = new TcpConnection( s, "tcp:",null ); |
| Assert.IsNull( c.GetSession() ); |
| |
| s.Close(); |
| t.Close(); |
| } |
| |
| [Test] |
| public void Constructor3() |
| { |
| IPEndPoint ipe = new IPEndPoint( IPAddress.Parse( "127.0.0.1" ), port ); |
| Socket s = new Socket( ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp ); |
| s.Connect( ipe ); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null, TIMEOUT, null ); |
| |
| TcpConnection c = new TcpConnection(s, "tcp:", null); |
| SessionData dh = new MyDataHandler(c); |
| Assert.AreEqual( dh, c.GetSession() ); |
| |
| s.Close(); |
| t.Close(); |
| } |
| |
| [Test] |
| [ExpectedException(typeof(ArgumentNullException))] |
| public void Constructor4() |
| { |
| new TcpConnection( null, (string) null, null ); |
| } |
| |
| [Test] |
| [ExpectedException(typeof(ArgumentNullException))] |
| public void Constructor5() |
| { |
| new TcpConnection( null, (string) null,null ); |
| } |
| |
| [Test] |
| public void Constructor8() |
| { |
| TcpConnection c = new TcpConnection( null,"tcp://localhost:"+port, null ); |
| Assert.IsNull( c.GetSession() ); |
| } |
| |
| [Test] |
| public void Constructor9() |
| { |
| |
| TcpConnection c = new TcpConnection(null, "tcp://localhost:" + port, null); |
| SessionData dh = new MyDataHandler(c); |
| Assert.AreEqual( dh, c.GetSession() ); |
| } |
| |
| #endregion |
| |
| #region Start variations |
| |
| [Test] |
| public void Start1() |
| { |
| IPEndPoint ipe = new IPEndPoint( IPAddress.Parse( "127.0.0.1" ), port ); |
| Socket s = new Socket( ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp ); |
| s.Connect( ipe ); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null, TIMEOUT, null ); |
| |
| |
| TcpConnection c = new TcpConnection( s,"tcp:",null ); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| Assert.IsFalse( c.IsStarted() ); |
| c.Start(); |
| Assert.IsTrue( c.IsStarted() ); |
| |
| c.WaitUp( TIMEOUT ); |
| |
| AssertWhat( What.UP, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| c.Flush(); |
| Assert.IsNotNull( c.RemoteAddress() ); |
| Assert.IsNotNull( c.LocalAddress() ); |
| Assert.AreEqual( c.RemoteAddress(), t.LocalEndPoint ); |
| Assert.AreEqual( c.LocalAddress(), t.RemoteEndPoint ); |
| |
| t.Close(); |
| |
| AssertWhat( What.DOWN, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| } |
| |
| [Test] |
| public void Start2() |
| { |
| IPEndPoint ipe = new IPEndPoint( IPAddress.Parse( "127.0.0.1" ), port ); |
| Socket s = new Socket( ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp ); |
| s.Connect( ipe ); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null, TIMEOUT, null ); |
| |
| |
| TcpConnection c = new TcpConnection(s, "tcp:", null ); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| Assert.IsFalse( c.IsStarted() ); |
| c.Start(); |
| Assert.IsTrue( c.IsStarted() ); |
| c.WaitUp( TIMEOUT ); |
| |
| AssertWhat( What.UP, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| Assert.IsTrue( c.IsStarted() ); |
| c.Stop(); |
| |
| Assert.IsFalse( c.IsStarted() ); |
| |
| c.WaitDown( TIMEOUT ); |
| |
| |
| AssertWhat( What.DOWN, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| t.Close(); |
| } |
| |
| [Test] |
| public void Start3() |
| { |
| |
| IPEndPoint ipe = new IPEndPoint( IPAddress.Parse( "127.0.0.1" ), port ); |
| Socket s = new Socket( ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp ); |
| s.Connect( ipe ); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null, TIMEOUT, null ); |
| |
| |
| TcpConnection c = new TcpConnection( s, "tcp:", null ); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| Assert.IsFalse( c.IsStarted() ); |
| c.Start(); |
| Assert.IsTrue( c.IsStarted() ); |
| |
| c.WaitUp( TIMEOUT ); |
| |
| AssertWhat( What.UP, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| Assert.IsTrue( c.IsStarted() ); |
| c.Close(); |
| |
| c.WaitDown( TIMEOUT ); |
| |
| AssertWhat( What.DOWN, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| t.Close(); |
| } |
| |
| [Test] |
| public void Start4() |
| { |
| |
| IPEndPoint ipe = new IPEndPoint( IPAddress.Parse( "127.0.0.1" ), port ); |
| Socket s = new Socket( ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp ); |
| |
| s.Connect( ipe ); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null, TIMEOUT, null ); |
| |
| |
| TcpConnection c = new TcpConnection( s, "tcp:", null ); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| Assert.IsFalse( c.IsStarted() ); |
| c.Start(); |
| Assert.IsTrue( c.IsStarted() ); |
| |
| c.WaitUp( TIMEOUT ); |
| |
| AssertWhat( What.UP, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| Assert.IsTrue( c.IsStarted() ); |
| c.Close( false ); |
| |
| c.WaitDown( TIMEOUT ); |
| |
| AssertWhat( What.DOWN, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| t.Close(); |
| } |
| |
| [Test] |
| public void Start5() |
| { |
| IPEndPoint ipe = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port); |
| Socket s = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp); |
| s.Connect(ipe); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet(null, TIMEOUT, null); |
| |
| TcpConnection c = new TcpConnection(s, "tcp:", null); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| Assert.IsFalse(c.IsStarted()); |
| c.Start(); |
| Assert.IsTrue(c.IsStarted()); |
| |
| c.WaitUp(TIMEOUT); |
| |
| AssertWhat(What.UP, dh.what); |
| Assert.IsNull(dh.xsender); |
| Assert.IsNull(dh.xbuf); |
| |
| Assert.IsTrue(c.IsStarted()); |
| c.Close(true); |
| |
| c.WaitDown(TIMEOUT); |
| |
| AssertWhat(What.DOWN, dh.what); |
| Assert.IsNull(dh.xsender); |
| Assert.IsNull(dh.xbuf); |
| |
| t.Close(); |
| } |
| |
| [Test] |
| public void Start6() |
| { |
| |
| TcpConnection c = new TcpConnection(null, "tcp://127.0.0.1:" + port, null); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| Assert.IsFalse( c.IsStarted() ); |
| c.Start(); |
| Assert.IsTrue( c.IsStarted() ); |
| c.WaitUp( TIMEOUT ); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null, TIMEOUT, null ); |
| |
| AssertWhat( What.UP, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| Assert.IsTrue( c.IsStarted() ); |
| c.Stop(); |
| Assert.IsFalse( c.IsStarted() ); |
| |
| AssertWhat( What.DOWN, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| t.Close(); |
| |
| } |
| |
| #endregion |
| |
| // Cause BuildServer to hang, hence ignored |
| [Ignore] |
| [Test] |
| public void restart1() |
| { |
| |
| |
| |
| TcpConnection c = new TcpConnection(null, "tcp://127.0.0.1:" + port + "?TcpTransport.reconnectDelay=200", null); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| c.Start(); |
| c.WaitUp( TIMEOUT ); |
| |
| int n = 10; |
| int i = 0; |
| while (++i <= n) |
| { |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null, TIMEOUT, null ); |
| |
| Console.WriteLine(String.Format( "accepted i {0} t.local {1} t.remote {2}", i, |
| t.LocalEndPoint, t.RemoteEndPoint )); |
| |
| AssertWhat( What.UP, dh.what ); |
| |
| Assert.AreEqual( t.LocalEndPoint, c.RemoteAddress() ); |
| Assert.AreEqual( t.RemoteEndPoint, c.LocalAddress() ); |
| byte[] data = new byte[] {Convert.ToByte(i)}; |
| |
| t.Send(data); |
| // t.getOutputStream().write( i ); |
| AssertWhat( What.DATA, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNotNull( dh.xbuf ); |
| Assert.AreEqual( 1, dh.xbuf.Length ); |
| Assert.AreEqual( (byte) i, dh.xbuf[0] ); |
| |
| // t.shutdownOutput(); |
| t.Shutdown(SocketShutdown.Send); |
| t.Close(); |
| t = null; |
| |
| AssertWhat( What.DOWN, dh.what ); |
| } |
| |
| Thread t1 = new Thread(new ThreadStart(RunMonitorSocketThread)); |
| |
| Thread t2 = new Thread(new ThreadStart(delegate() |
| { |
| |
| try |
| { |
| Object t; |
| Monitor<What> mon = dh.what; |
| while ((t = mon.WaitUntilNotEqAndSet(default(What), TIMEOUT, default(What))) != null) { } |
| // Log.report( "harvested", "mon", mon, "t", t ); |
| } |
| catch (Exception) |
| { |
| // ignore |
| } |
| |
| |
| |
| })); |
| |
| // Thread t1 = new MonitorHarvester<Socket>( lh.accepted ); |
| t1.Start(); |
| // Thread t2 = new MonitorHarvester<What>( dh.what ); |
| t2.Start(); |
| |
| Console.WriteLine( "stopping" ); |
| c.Stop(); |
| c.WaitDown( TIMEOUT ); |
| Console.WriteLine( "stoppped" ); |
| |
| t1.Join(); |
| t2.Join(); |
| } |
| |
| private void RunMonitorSocketThread() |
| { |
| try |
| { |
| Object t; |
| Monitor<Socket> mon = lh.accepted; |
| while ((t = mon.WaitUntilNotEqAndSet(null, TIMEOUT, null)) != null) |
| { |
| // Log.report( "harvested", "mon", mon, "t", t ); |
| } |
| |
| } |
| catch (Exception) |
| { |
| // ignore |
| } |
| } |
| |
| |
| /** |
| * @param <T> |
| */ |
| public class MonitorHarvester<T> |
| { |
| /** |
| * @param mon |
| */ |
| public MonitorHarvester( Monitor<T> mon ) |
| { |
| this.mon = mon; |
| |
| } |
| |
| private readonly Monitor<T> mon; |
| |
| |
| } |
| // Cause BuildServer to hang, hence ignored |
| [Ignore] |
| [Test] |
| public void restart2() |
| { |
| |
| |
| |
| TcpConnection c = new TcpConnection(null, "tcp://127.0.0.1:" + port + "?TcpTransport.reconnectDelay=200", null); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| c.Start(); |
| c.WaitUp( TIMEOUT ); |
| |
| int n = 10; |
| int i = 0; |
| while (++i <= n) |
| { |
| // Log.report( "--- waitAccepted" ); |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null, TIMEOUT, null ); |
| |
| Console.WriteLine(String.Format("accepted i {0} t.local {1} t.remote {2}", i, |
| t.LocalEndPoint, t.RemoteEndPoint)); |
| |
| AssertWhat( What.UP, dh.what ); |
| // Log.report( "up", "c.local", c.localAddress(), "c.remote", c.remoteAddress() ); |
| |
| Assert.AreEqual( t.LocalEndPoint, c.RemoteAddress() ); |
| Assert.AreEqual( t.RemoteEndPoint, c.LocalAddress() ); |
| |
| byte[] data = new byte[] { Convert.ToByte(i) }; |
| |
| t.Send(data); |
| AssertWhat( What.DATA, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNotNull( dh.xbuf ); |
| Assert.AreEqual( 1, dh.xbuf.Length ); |
| Assert.AreEqual( (byte) i, dh.xbuf[0] ); |
| |
| // Log.report( "c.shutingDownOutput" ); |
| c.ShutdownOutput(); |
| // Log.report( "c.shutdownOutput" ); |
| |
| // Log.report( "t.reading" ); |
| Assert.AreEqual( 0, t.Receive(data) ); |
| // Log.report( "t.eof" ); |
| |
| t.Shutdown(SocketShutdown.Send); |
| t.Close(); |
| t = null; |
| |
| AssertWhat( What.DOWN, dh.what ); |
| // Log.report( "down" ); |
| } |
| |
| Thread t1 = new Thread(new ThreadStart(RunMonitorSocketThread)); |
| t1.Start(); |
| Thread t2 = new Thread(new ThreadStart(delegate() |
| { |
| |
| try |
| { |
| Object t; |
| Monitor<What> mon = dh.what; |
| while ((t = mon.WaitUntilNotEqAndSet(default(What), TIMEOUT, default(What))) != null) { } |
| // Log.report( "harvested", "mon", mon, "t", t ); |
| } |
| catch (Exception) |
| { |
| // ignore |
| } |
| |
| |
| |
| })); |
| t2.Start(); |
| |
| Console.WriteLine( "stopping" ); |
| c.Stop(); |
| c.WaitDown( TIMEOUT ); |
| Console.WriteLine( "stopped" ); |
| |
| t1.Join(); |
| t2.Join(); |
| } |
| |
| #region Data tests |
| |
| [Test] |
| public void Data1() |
| { |
| |
| TcpConnection c = new TcpConnection(null, "tcp://127.0.0.1:" + port, null); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| Assert.IsFalse( c.IsStarted() ); |
| c.Start(); |
| Assert.IsTrue( c.IsStarted() ); |
| |
| c.WaitUp( TIMEOUT ); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null, TIMEOUT, null ); |
| |
| AssertWhat( What.UP, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| byte[] buf = new byte[] { 23 }; |
| t.Send( buf ); |
| |
| AssertWhat( What.DATA, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNotNull( dh.xbuf ); |
| Assert.AreEqual( 1, dh.xbuf.Length ); |
| Assert.AreEqual( ( byte ) 23, dh.xbuf[ 0 ] ); |
| |
| Assert.IsTrue( c.IsStarted() ); |
| c.Stop(); |
| Assert.IsFalse( c.IsStarted() ); |
| |
| AssertWhat( What.DOWN, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| t.Close(); |
| |
| } |
| |
| [Test] |
| public void Data2() |
| { |
| |
| TcpConnection c = new TcpConnection(null, "tcp://127.0.0.1:" + port, null); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| Assert.IsFalse( c.IsStarted() ); |
| c.Start(); |
| Assert.IsTrue( c.IsStarted() ); |
| |
| c.WaitUp( TIMEOUT ); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null,TIMEOUT, null ); |
| |
| AssertWhat( What.UP, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| byte[] buf = { 21, 22, 23 }; |
| |
| t.Send( buf ); |
| // t.getOutputStream().flush(); |
| |
| AssertWhat( What.DATA, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNotNull( dh.xbuf ); |
| Assert.AreEqual( 3, dh.xbuf.Length ); |
| Assert.AreEqual( ( byte ) 21, dh.xbuf[ 0 ] ); |
| Assert.AreEqual( ( byte ) 22, dh.xbuf[ 1 ] ); |
| Assert.AreEqual( ( byte ) 23, dh.xbuf[ 2 ] ); |
| |
| Assert.IsTrue( c.IsStarted() ); |
| c.Stop(); |
| Assert.IsFalse( c.IsStarted() ); |
| |
| AssertWhat( What.DOWN, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| t.Close(); |
| } |
| |
| [Test] |
| public void Data3() |
| { |
| |
| TcpConnection c = new TcpConnection(null, "tcp://127.0.0.1:" + port, null); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| Assert.IsFalse( c.IsStarted() ); |
| c.Start(); |
| Assert.IsTrue( c.IsStarted() ); |
| |
| c.WaitUp( TIMEOUT ); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null, TIMEOUT, null ); |
| |
| AssertWhat( What.UP, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| t.Shutdown( SocketShutdown.Send ); |
| |
| AssertWhat( What.DOWN, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| t.Close(); |
| c.Close(); |
| } |
| |
| [Test] |
| public void Data4() |
| { |
| |
| TcpConnection c = new TcpConnection(null, "tcp://127.0.0.1:" + port, null); |
| MyDataHandler dh = new MyDataHandler(c); |
| |
| c.Start(); |
| |
| c.WaitUp( TIMEOUT ); |
| |
| Socket t = lh.accepted.WaitUntilNotEqAndSet( null,TIMEOUT, null ); |
| |
| AssertWhat( What.UP, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| byte[] sendBuf = new byte[] { 21, 22, 23 }; |
| |
| // c.Data( null, new FlexBuffer( sendBuf ) ); |
| c.TransportData(null, new FlexBuffer(sendBuf)); |
| // c.flush(); |
| |
| byte[] receiveBuf = new byte[ 3 ]; |
| t.Receive( receiveBuf ); |
| |
| Assert.AreEqual( sendBuf, receiveBuf ); |
| |
| c.ShutdownOutput(); |
| |
| // Assert.AreEqual( -1, is.read() ); |
| |
| c.Close(); |
| |
| AssertWhat( What.DOWN, dh.what ); |
| Assert.IsNull( dh.xsender ); |
| Assert.IsNull( dh.xbuf ); |
| |
| t.Close(); |
| } |
| |
| #endregion |
| |
| |
| private void AssertWhat( What what, Monitor<What> mon ) |
| { |
| mon.WaitUntilEqAndSet( what, TIMEOUT, default( What) ); |
| } |
| |
| public enum What { |
| // connection is up |
| UP, |
| // connection is down |
| DOWN, |
| // connection read some data |
| DATA |
| }; |
| |
| #region Filler classes |
| |
| public class MyListener : SessionListener<Socket> |
| { |
| public Monitor<Socket> accepted = new Monitor<Socket>( "accepted" ); |
| |
| public void Accepted( Socket s ) |
| { |
| // accepted.Set( s ); |
| accepted.WaitUntilEqAndSet(null, TIMEOUT, s); |
| } |
| |
| |
| #endregion |
| |
| #region Session Members |
| |
| public object SessionQuery( object query ) |
| { |
| // ignore |
| throw new NotSupportedException("unknown query: " + query); |
| } |
| |
| public void SessionControl( object control, object value ) |
| { |
| // ignore |
| throw new NotSupportedException("unknown control: " + control); |
| } |
| |
| public void SessionNotify( object eventObj ) |
| { |
| // ignore |
| if (eventObj is Exception) |
| Console.WriteLine("MyListener.SessionNotify: " + eventObj); |
| } |
| |
| #endregion |
| |
| #region SessionListener Members |
| |
| public void SessionAccepted(Socket socket) |
| { |
| accepted.WaitUntilEqAndSet(null, TIMEOUT, socket); |
| } |
| |
| #endregion |
| } |
| |
| public class MyDataHandler : SessionData |
| { |
| // holds event type |
| public Monitor<What> what = new Monitor<What>( "what" ); |
| |
| // sender of the event if DATA |
| public Who xsender; |
| |
| // data of the event if DATA |
| public byte[] xbuf; |
| |
| //public void Data( Who sender, FlexBuffer buf ) |
| //{ |
| // xsender = sender; |
| // xbuf = buf.GetAvailBytes(); |
| |
| // what.WaitUntilEqAndSet(default(What), TIMEOUT, What.DATA); |
| //} |
| public MyDataHandler(TcpConnection conn) |
| { |
| conn.SetSession(this); |
| } |
| |
| |
| #region Session Members |
| |
| public object SessionQuery( object query ) |
| { |
| throw new NotSupportedException( " Unsupported query " + query ); |
| } |
| |
| public void SessionControl( object control, object value ) |
| { |
| throw new NotSupportedException( " Unsupported control " + control ); |
| } |
| |
| public void SessionNotify( object eventObj ) |
| { |
| if ( eventObj.Equals( SessionConsts.UP ) ) |
| { |
| xbuf = null; |
| // what.Set( What.UP ); |
| what.WaitUntilEqAndSet(default(What), TIMEOUT, What.UP); |
| return; |
| } |
| |
| if ( eventObj.Equals( SessionConsts.DOWN ) ) |
| { |
| xbuf = null; |
| what.WaitUntilEqAndSet(default(What), TIMEOUT, What.DOWN); |
| return; |
| } |
| } |
| |
| #endregion |
| |
| #region SessionData Members |
| |
| public void SessionData(Who sender, FlexBuffer buf) |
| { |
| xsender = sender; |
| xbuf = buf.GetAvailBytes(); |
| |
| what.WaitUntilEqAndSet(default(What), TIMEOUT, What.DATA); |
| } |
| |
| #endregion |
| } |
| |
| } |
| } |