init

Common/DTS.Common.IConnection/.svn/pristine/65/65fff28e3a0d68ab76e47d0ee118b97b59b6a0ea.svn-base

@@ -0,0 +1,218 @@
+using DTS.Common.Interface.Connection;
+using DTS.Common.Utilities.Logging;
+using System;
+using System.CodeDom;
+using System.Collections.Specialized;
+using System.Net.Sockets;
+using System.Runtime.Remoting.Messaging;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace DTS.DASLib.Connection
+{
+    public class RESTConnection : IConnection
+    {
+        bool IConnection.IsSoftDisconnected => false;
+
+        SocketFlags IConnection.Flags { get; set; } = SocketFlags.None;
+
+        private string _hostIPAddress = string.Empty;
+        private string _ConnectString = string.Empty;
+        string IConnection.ConnectString => _ConnectString;
+
+        private bool _bConnected = false;
+        bool IConnection.Connected => _bConnected;
+
+
+        public event EventHandler OnDisconnected;        
+
+        internal class AsyncNoResult : IAsyncResult
+        {
+            private readonly AsyncCallback _callback;
+            private readonly object _state;
+            private ManualResetEvent _waitHandle;
+            private const int PENDING = 0;
+            private const int COMPLETED_SYNC = 1;
+            private const int COMPLETED_ASYNC = 2;
+            private int _executionState = PENDING;
+
+
+            bool IAsyncResult.IsCompleted => Thread.VolatileRead(ref _executionState) != PENDING;
+
+            WaitHandle IAsyncResult.AsyncWaitHandle
+            {
+                get
+                {
+                    if (_waitHandle == null)
+                    {
+                        var done = ((IAsyncResult)this).IsCompleted;
+                        ManualResetEvent mre = new ManualResetEvent(done);
+                        if (Interlocked.CompareExchange(ref _waitHandle,
+                           mre, null) != null)
+                        {
+                            // Another thread created this object's event; dispose 
+                            // the event we just created
+                            mre.Close();
+                        }
+                        else
+                        {
+                            if (!done && ((IAsyncResult)this).IsCompleted)
+                            {
+                                // If the operation wasn't done when we created 
+                                // the event but now it is done, set the event
+                                _waitHandle.Set();
+                            }
+                        }
+                    }
+                    return _waitHandle;
+                }
+            }
+
+            object IAsyncResult.AsyncState => _state;
+
+            bool IAsyncResult.CompletedSynchronously => Thread.VolatileRead(ref _executionState) == COMPLETED_SYNC;
+
+            public AsyncNoResult(AsyncCallback callback, object state)
+            {
+                _callback = callback;
+                _state = state;
+            }
+            public void SetCompleted(bool completedSync)
+            {
+                var prevState = Interlocked.Exchange(ref _executionState, completedSync ? COMPLETED_SYNC : COMPLETED_ASYNC);
+
+                if (prevState != PENDING)
+                {
+                    throw new InvalidOperationException("Complete called on an operation already complete");
+                }
+                _waitHandle?.Set();
+                _callback?.Invoke(this);
+            }
+        }
+
+        private IAsyncResult GetAlreadyCompleted(AsyncCallback callback, object state)
+        {
+            var result = new AsyncNoResult(callback, state);
+            result.SetCompleted(true);
+            return result;
+        }
+
+        IAsyncResult IConnection.BeginAccept(AsyncCallback callback, object state)
+        {
+            return GetAlreadyCompleted(callback, state);
+        }
+
+        IAsyncResult IConnection.BeginConnect(AsyncCallback callback, object callbackObject)
+        {
+            _bConnected = true;
+            //we could check ConnectString and test REST API port
+            return GetAlreadyCompleted(callback, callbackObject);
+        }
+
+        IAsyncResult IConnection.BeginDisconnect(bool reuseSocket, AsyncCallback callback, object state)
+        {
+            _bConnected = false;
+            return GetAlreadyCompleted(callback, state);
+        }
+
+        IAsyncResult IConnection.BeginReceive(byte[] receiveBuffer, int bufferStartOffset, int maxSizeToReceive, AsyncCallback callback, object callbackObject)
+        {
+            return GetAlreadyCompleted(callback, callbackObject);
+        }
+
+        IAsyncResult IConnection.BeginSend(byte[] sendBuffer, int bufferStartOffset, int bufferSizeToSend, AsyncCallback callback, object callbackObject)
+        {
+            return GetAlreadyCompleted(callback, callbackObject);
+        }
+
+        void IConnection.Bind(int port)
+        {
+            //not really needed
+        }
+
+        void IConnection.Create(string connectString)
+        {
+            _ConnectString = connectString;
+        }
+
+        void IConnection.Create(string connectString, string hostIPAddress)
+        {
+            _ConnectString = connectString;
+            _hostIPAddress = hostIPAddress;
+        }
+        private bool _disposed = false;
+
+        ~RESTConnection()
+        {
+            Dispose(false);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed) { return; }
+
+            //do any cleanup of sockets, etc here if disposing is true
+
+            _disposed = true;
+        }
+
+        IConnection IConnection.EndAccept(IAsyncResult asyncResult)
+        {
+            //ethernet connection returns a copy, but I'm not sure why
+            return this;
+        }
+
+        void IConnection.EndConnect(IAsyncResult ar)
+        {            
+        }
+
+        void IConnection.EndDisconnect(IAsyncResult asyncResult)
+        {            
+        }
+
+        int IConnection.EndReceive(IAsyncResult ar)
+        {
+            return 0;
+        }
+
+        int IConnection.EndSend(IAsyncResult ar)
+        {
+            return 0;
+        }
+
+        string IConnection.GetConnectionData()
+        {
+            return $"{_ConnectString} - {_hostIPAddress}";
+        }
+
+        void IConnection.KeepAliveErrorReceived()
+        {            
+        }
+
+        void IConnection.Listen(int backlog)
+        {            
+        }
+
+        Task<int> IConnection.SendAsync(byte[] sendBuffer, int bufferStartOffset, int bufferSizeToSend)
+        {
+            return Task<int>.Factory.FromAsync(
+                (callback, state) => ((IConnection)this).BeginSend(sendBuffer, bufferStartOffset, bufferSizeToSend, callback, state),
+                ((IConnection)this).EndSend, state: null
+                );
+        }
+
+        void IConnection.SoftConnect()
+        {            
+        }
+
+        void IConnection.SoftDisconnect()
+        {
+        }
+    }
+}