modification structure svn

1 files changed, 592 insertions, 0 deletions

diff --git a/Ivy/IvyClient.cs b/Ivy/IvyClient.cs
new file mode 100644
index 0000000..3db9f0f
--- /dev/null
+++ b/Ivy/IvyClient.cs
@@ -0,0 +1,592 @@
+/// François-Régis Colin

+/// http://www.tls.cena.fr/products/ivy/

+/// *

+/// (C) CENA

+/// *

+namespace IvyBus

+{

+	using System;

+	using System.Collections;

+    using System.Collections.Specialized;

+    using System.Collections.Generic;

+	using System.Threading;

+	using System.Text;

+	using System.IO;

+	using System.Net;

+	using System.Net.Sockets;

+	using System.Configuration;

+    using System.Diagnostics;

+

+	/// <summary> A Class for the the peers on the bus.

+	/// </summary>

+	/// <remarks>

+	/// each time a connexion is made with a remote peer, the regexp are exchanged

+	/// once ready, a ready message is sent, and then we can send messages, 

+	/// die messages, direct messages, add or remove regexps, or quit. A thread is

+	/// created for each remote client.

+	/// </remarks>

+    public class IvyClient : IvyProtocol, IComparable<IvyClient>, IDisposable  

+	{

+        public int CompareTo(IvyClient other)

+        {

+            return (other.clientPriority - clientPriority);

+        }

+

+		public String ApplicationName

+		{

+			get

+			{

+				return appName;

+			}

+			

+		}

+

+        public List<string> Regexps

+		{

+			get

+			{

+                List<string> tab = new List<string>();

+                lock (bindings)

+                {

+                    foreach (IvyBindingBase bind in bindings.Values)

+                        tab.Add(bind.Expression);

+                }

+				return tab;

+			}

+			

+		}

+		internal int AppPort

+		{

+			get

+			{

+				return appPort;

+			}

+			

+		}

+        public IPAddress RemoteAddress

+		{

+			get

+			{

+                return remoteHost;

+			}

+			

+		}

+		public int RemotePort

+		{

+			get

+			{

+                return remotePort;

+			}

+			

+		}

+		

+		private Ivy bus;

+        private Dictionary<ushort,IvyBindingBase> bindings;

+		private int appPort;

+		private string clientId;	/* an unique ID for each IvyClient */

+		private int clientPriority;	/* client priority */

+		

+		private volatile Thread clientThread; // volatile to ensure the quick communication

+        private bool doping; // false by runtime default

+		private const int PINGTIMEOUT = 5000;

+		private volatile Thread pingerThread;

+

+        private int remotePort;

+        private IPAddress remoteHost;

+		

+		// protected variables

+		internal String appName;

+        internal IvyProtocol stream;

+

+		internal IvyClient(Ivy bus, Socket socket, string appname)

+		{

+			bindings = new Dictionary<ushort,IvyBindingBase>();

+			appName = appname;

+			this.bus = bus;

+            

+            IPEndPoint endpoint = (IPEndPoint)socket.RemoteEndPoint;

+

+            remoteHost = endpoint.Address;

+            remotePort = endpoint.Port;

+                

+#if (!PocketPC )

+            socket.SetSocketOption( SocketOptionLevel.Tcp, SocketOptionName.KeepAlive, 1 );

+#endif

+

+            if ( bus.ProtocolVersion == 4 )

+    			stream = new IvyTCPStreamV4( socket, this );

+                else

+                stream = new IvyTCPStreamV3(socket, this);

+

+			clientPriority = Ivy.DEFAULT_PRIORITY;

+            // spawns a thread to manage the incoming traffic on this

+            // socket. We should be ready to receive messages now.

+            clientThread = new Thread(new ThreadStart(this.Run));

+            clientThread.Name = "Ivy Tcp Client Reader Thread ("+appname+")";

+            clientThread.Start();

+

+		}

+

+        internal void SendBindings()

+        {

+            try

+            {

+                stream.TokenApplicationId(bus.applicationPriority, bus.AppId);

+

+                // sends our ID, whether we initiated the connexion or not

+                // the ID is the couple "host name,application Port", the host name

+                // information is in the socket itself, the port is not known if we

+                // initiate the connexion

+                stream.TokenStartRegexp(bus.applicationPort, bus.appName);

+                // sends our regexps to the peer

+                lock (bus.bindings)

+                {

+                    foreach (IvyApplicationBinding bind in bus.bindings.Values)

+                    {

+                        stream.TokenAddBinding(bind.Binding, bind.Key, bind.FormatedExpression);

+                    }

+                }

+                stream.TokenEndRegexp();

+              

+#if (!PocketPC)

+                doping = Properties.Settings.Default.IvyPing;

+#endif

+                if (doping)

+                {

+                    pingerThread = new Thread(new ThreadStart(PingerRun));

+                    pingerThread.Name = "Ivy Pinger Thread";

+                    pingerThread.Start();

+                }

+

+

+            }

+            catch (IOException ex)

+            { // the client nous a coupé l'herbe sous le pied 

+                Ivy.traceError("IvyClient","I can't send my message to this client. He probably left " + ex.Message);

+                // invokes the Disconnected applicationListeners

+                //bus.OnClientDisconnected(new IvyEventArgs(this,id, message ));

+                // called by the receiver Thread

+                close(false);

+            }

+        }

+		

+		/// <summary>  returns the name of the remote agent.

+		/// allow an Ivy package class to access the list of regexps at a

+		/// given time.

+		/// perhaps we should implement a new IvyApplicationListener method to

+		/// allow the notification of regexp addition and deletion

+		/// </summary>

+		

+		/// <summary> sends a direct message to the peer

+		/// </summary>

+		/// <param name='id'>the numeric value provided to the remote client

+		/// </param>

+		/// <param name='message'>the string that will be match-tested

+		/// 

+		/// </param>

+        public void SendDirectMsg(ushort id, string message)

+		{

+			try 

+			{

+                stream.TokenDirectMsg( id, message);

+			}

+			catch (IOException ex)

+			{

+				Ivy.traceError("IvyClient","I can't send my message to this client. He probably left "+ex.Message);

+				// first, I'm not a first class IvyClient any more

+				bus.removeClient(this);

+				// invokes the Disconnected applicationListeners

+                //bus.OnClientDisconnected(new IvyEventArgs(this,id, message ));

+                // should be called by receiver thread

+				close(false);

+			}

+		}

+		

+		/// <summary> closes the connexion to the peer.

+		/// </summary>

+		/// <param name='notify'>should I send Bye message ?

+		/// the thread managing the socket is stopped

+		/// 

+		/// </param>

+		internal void  close(bool notify)

+		{

+			Ivy.traceProtocol("IvyClient","closing connexion to " + appName);

+			if (doping )

+			{

+				StopPinging();

+			}

+			if (notify)

+                try

+                {

+                    stream.TokenBye(0, "hasta la vista");

+                }

+                catch (IOException ioe)

+                {

+                    throw new IvyException(ioe.Message);

+                }

+            // stop the thread and close the stream

+            if (clientThread == null)

+                return;

+            // Tell Thread to stop.

+            if (stream != null)

+            {

+                try

+                {

+                    stream.Close();    // should stop the Reading Client Thread 

+                }

+                catch (IOException ioe)

+                {

+                    throw new IvyException(ioe.Message);

+                }

+                //socket.Close(); // pris en charge par stream ( NetWorkStream )

+                stream = null;

+            }

+            // Potential dead lok when thread issue ClientDisconnected event

+            //if (Thread.CurrentThread != clientThread && (clientThread != null))

+            //{

+            //    // Wait for Thread to end.

+            //    bool term = clientThread.Join(10000);

+            //    if (!term && (clientThread != null)) clientThread.Abort();

+            //}

+

+            clientThread = null;

+            

+		

+		}

+		

+		/// <summary> sends the substrings of a message to the peer for each matching regexp.

+		/// </summary>

+		/// <param name='message'>the string that will be match-tested

+		/// </param>

+		/// <returns>the number of messages sent to the peer

+		/// 

+		/// </returns>

+		internal int sendMsg(String message)

+		{

+			int count = 0;

+                    

+			lock( bindings )

+            {

+                try

+                {

+                    foreach (IvyBindingBase bind in bindings.Values)

+                    {

+                        string[] args = bind.Match(message);

+                        if (stream != null && args != null)

+                        {

+                            stream.TokenMsg(bind.Key, args);

+                            count++;

+                        }

+                    }

+                }

+                catch (IOException ex)

+                {

+                    Ivy.traceError("IvyClient","I can't send my message to this client. He probably left " + ex.Message);

+                    // first, I'm not a first class IvyClient any more

+                    bus.removeClient(this);

+                    // invokes the Disconnected applicationListeners

+                    // in the receiver thread

+                    close(false);

+                }

+			

+               

+			}

+			return count;

+		}

+		

+		/// <summary> compares two peers the id is the couple (host,service port).

+		/// </summary>

+		/// <param name='clnt'>the other peer

+		/// </param>

+		/// <returns>true if the peers are similir. This should not happen, it is bad

+		/// © ® (tm)

+		/// 

+		/// </returns>

+		internal bool sameClient(IvyClient clnt)

+		{

+			return (appPort != 0 && appPort == clnt.appPort) && (RemoteAddress == clnt.RemoteAddress);

+		}

+		

+		/// <summary> the code of the thread handling the incoming messages.

+		/// </summary>

+		private void  Run()

+		{

+			Ivy.traceProtocol("IvyClient","Connected from " + RemoteAddress + ":" + RemotePort);

+			

+			Ivy.traceProtocol("IvyClient","Thread started");

+			

+			bool running = true;

+			while ( running && (stream != null) )

+			{

+				try

+				{

+					if ( stream.receiveMsg() )

+					{

+						// early stop during readLine()

+						if (doping && (pingerThread != null))

+							pingerThread.Abort();

+					}

+					else

+					{

+						Ivy.traceProtocol("IvyClient","receiveMsg false ! leaving the thread");

+                        running = false;

+						break;

+					}

+				}

+				catch ( ObjectDisposedException ex )

+				{

+					Ivy.traceError("IvyClient", "socket closed "+ex.Message );

+					running = false;

+					break;

+				}

+				catch (IvyException ie)

+				{

+                    Ivy.traceError("IvyClient","socket closed IvyException" + ie.Message);

+                    running = false;

+					break;

+				}

+				catch (SocketException se)

+				{

+					Ivy.traceError("IvyClient", "socket closed "+se.Message );

+					running = false;

+					break;

+				}

+				catch (IOException ex)

+				{

+					if ( ex.InnerException is SocketException )

+					{

+						Ivy.traceProtocol("IvyClient", "socket closed" );

+					

+					}

+					else 

+					{

+						Ivy.traceError("IvyClient","abnormally Disconnected from " + RemoteAddress + ":" + RemotePort);

+					}

+					running = false;

+					break;

+				}

+			}

+			Ivy.traceProtocol("IvyClient","normally Disconnected from " + appName);

+			Ivy.traceProtocol("IvyClient","Thread stopped");

+			// invokes the Disconnected applicationListeners

+            bus.OnClientDisconnected(new IvyEventArgs(this,0, "" ));

+			// first, I'm not a first class IvyClient any more

+            if (stream != null)

+            {

+                stream.Close();

+                stream = null;

+            }

+			bus.removeClient(this);

+			

+		}

+        void IvyProtocol.Close()

+        {

+            // never call in this side

+        }

+        bool IvyProtocol.receiveMsg()

+        {

+            // nerver call in this side

+            return false;

+        }

+        void IvyProtocol.TokenDie(ushort id, string arg)

+		{

+			Ivy.traceProtocol("IvyClient","received die Message from " + appName + "Raison: "+ arg);

+			// invokes the die applicationListeners

+            IvyDieEventArgs ev = new IvyDieEventArgs(this, id, arg);

+            bus.OnDie(ev);

+            // first, I'm not a first class IvyClient any more

+            bus.removeClient(this);

+            // makes the bus die

+			bus.Stop();

+			close(false);

+            if (ev.ForceExit)

+#if (PocketPC)

+                System.Windows.Forms.Application.Exit();

+#else

+				System.Environment.Exit(0);

+#endif

+		}

+        void IvyProtocol.TokenBye(ushort err, string arg)

+		{

+			// the peer quits

+			Ivy.traceProtocol("IvyClient","received bye Message from " + appName + "Raison: "+ arg);

+			// first, I'm not a first class IvyClient any more

+			//bus.removeClient(this); // this is done in the receive thread terminaison!!

+			// invokes the disconnect applicationListeners

+			//bus.FireClientDisconnected(this); done in Running Thread

+			close(false);  // will fire disconnected

+		}

+

+        void IvyProtocol.TokenAddBinding(BindingType type, ushort id, string expression)

+		{

+			

+            if (type == BindingType.Regexp && !bus.CheckRegexp(expression))

+            {

+            bus.OnClientFilterBinding(new IvyEventArgs(this, id, expression ));

+            return;

+            }

+            IvyBindingBase bind = null;

+            try

+            {

+                switch (type)

+                {

+                    case BindingType.Regexp:

+                        bind = new IvyBindingRegexp(id, expression);

+                        break;

+                    case BindingType.Simple:

+                        bind = new IvyBindingSimple(id, expression);

+                        break;

+                }

+                lock (bindings)

+                {

+                    bindings.Add(id, bind);

+                }

+

+                bus.OnClientAddBinding(new IvyEventArgs(this, id, expression));

+                

+			}

+			catch (ArgumentException ex)

+			{

+				throw new IvyException("binding expression error " + ex.Message);

+			}

+					

+		}

+        void IvyProtocol.TokenDelBinding(ushort id)

+		{

+			lock( bindings )

+			{

+                try

+                {

+                    IvyBindingBase bind = bindings[id];

+                    bus.OnClientRemoveBinding(new IvyEventArgs(this, bind.Key, bind.Expression));

+                    bindings.Remove(id);

+                }

+                catch (KeyNotFoundException ex)

+                {

+                    Ivy.traceError("IvyClient","DelBinding " + ex.Message);

+                }

+			}

+		}

+        void IvyProtocol.TokenMsg(ushort id, string[] args)

+		{

+            bus.OnMessage(new IvyMessageEventArgs(this, id, args));		

+		}

+        void IvyProtocol.TokenError(ushort id, string arg)

+		{

+            bus.OnError(new IvyEventArgs(this, id, arg));

+			Ivy.traceError("IvyClient","Error msg " + id + " " + arg);

+		}

+        void IvyProtocol.TokenApplicationId(ushort id, string arg)

+		{

+			clientId = arg;

+			if ( clientPriority != id )

+			{

+				clientPriority = id;

+				bus.SortClients();

+			}

+		}

+        void IvyProtocol.TokenEndRegexp()

+		{

+            /* 

+            * the peer is perhaps not ready to handle this message

+            * an assymetric processing should be written

+            */

+            if (bus.ReadyMessage != null)

+                sendMsg(bus.ReadyMessage);

+            bus.OnClientConnected(new IvyEventArgs(this, 0, ""));

+		}

+        void IvyProtocol.TokenStartRegexp(ushort id, string arg)

+		{

+			appName = arg;

+			appPort = id;

+			if (bus.checkConnected(this))

+			{

+				close(false);

+				throw new IvyException("Rare ! A concurrent connect occured");

+			}

+					

+		}

+        void IvyProtocol.TokenDirectMsg(ushort id, string arg)

+		{

+            bus.OnDirectMessage(new IvyEventArgs(this,id,arg));

+		}

+        void IvyProtocol.TokenPing(string arg)

+		{

+			// I receive a ping. I can answer a pong.

+			Ivy.traceProtocol("IvyClient","Ping msg from " + appName + " : " +  arg );

+			stream.TokenPong(arg);

+		}

+        void IvyProtocol.TokenPong(string arg)

+		{

+			Ivy.traceProtocol("IvyClient","Ping msg from " + appName + " : " + arg);

+		}

+		

+		

+		

+		public override String ToString()

+		{

+			return "IvyClient " + bus.appName + ":" + appName;

+		}

+

+		/* is the Pinging Thread Runninng */

+		internal bool isPinging;

+

+		private void  PingerRun()

+		{

+			isPinging = true;

+			Ivy.traceProtocol("IvyClient","Pinger Thread started");

+			while (isPinging)

+			{

+				try

+				{

+					Thread.Sleep(PINGTIMEOUT);

+					stream.TokenPing("are you here ?");

+				}

+				catch (ThreadAbortException ie)

+				{

+                    Ivy.traceError("IvyClient","Pinger Thread killed "+ie.Message);

+				}

+			}

+			Ivy.traceProtocol("IvyClient","Pinger Thread stopped");

+		}

+		public virtual void  StopPinging()

+		{

+			isPinging = false; 

+			//pingerThread.Interrupt();

+            pingerThread.Abort();

+		}

+

+        #region IDisposable Members

+

+         //Implement IDisposable.

+        public void Dispose()

+        {

+            Dispose(true);

+            GC.SuppressFinalize(this);

+        }

+

+        protected virtual void Dispose(bool disposing)

+        {

+            if (disposing)

+            {

+                // Free other state (managed objects).

+            }

+            // Free your own state (unmanaged objects).

+            // Set large fields to null.

+            if (stream != null)

+            {

+                stream.Close();

+                stream = null;

+            }

+        }

+

+        // Use C# destructor syntax for finalization code.

+        ~IvyClient()

+        {

+            // Simply call Dispose(false).

+            Dispose(false);

+        }

+

+        #endregion

+    }

+}
\ No newline at end of file