Work on new Zily protocol

src/Zily.csproj

@@ -27,11 +27,9 @@
    </PropertyGroup>
 
   <ItemGroup>
-    <Compile Remove="StreamWrapper.cs" />
     <Compile Remove="ZilyPipeClientStream.cs" />
     <Compile Remove="ZilyPipeServerStream.cs" />
     <Compile Remove="ZilyPipeStream.cs" />
-    <Compile Remove="ZilyStream.cs" />
     <Compile Remove="ZilyTextWriter.cs" />
   </ItemGroup>
 
@@ -40,11 +38,9 @@
       <Pack>True</Pack>
       <PackagePath>\</PackagePath>
     </None>
-    <None Include="StreamWrapper.cs" />
     <None Include="ZilyPipeClientStream.cs" />
     <None Include="ZilyPipeServerStream.cs" />
     <None Include="ZilyPipeStream.cs" />
-    <None Include="ZilyStream.cs" />
     <None Include="ZilyTextWriter.cs" />
   </ItemGroup>
 

src/ZilyHeader.cs

@@ -70,7 +70,7 @@ private ZilyHeader(int flag, string text, byte[] unicode_text)
         /// <returns>
         /// A new instance of the <see cref="ZilyHeader"/>.
         /// </returns>
-        public virtual ZilyHeader Parse(Stream stream)
+        public static ZilyHeader Parse(Stream stream)
         {
             int flag;
             string text = null;

src/ZilyHeaderFlag.cs

@@ -28,5 +28,15 @@ public class ZilyHeaderFlag
         /// Indicates a potential abnormal state.
         /// </summary>
         public const int Warn = 3;
+
+        /// <summary>
+        /// Indicates an established connection.
+        /// </summary>
+        public const int Connected = 4;
+
+        /// <summary>
+        /// Indicates an refused connection.
+        /// </summary>
+        public const int Disconnected = 5;
     }
 }

src/ZilySide.cs

@@ -9,6 +9,13 @@ public class ZilySide : Side
     {
         int last_request;
 
+        /// <summary>
+        /// Gets the proper flag for disconnect message.
+        /// </summary>
+        public virtual int DisconnectFlag => ZilyHeaderFlag.Disconnected;
+
+        internal ZilyStream zs;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ZilySide"/>.
         /// </summary>
@@ -68,6 +75,12 @@ public virtual void ParseHeader(ZilyHeader header)
                 case ZilyHeaderFlag.Fail:
                     // Throw an exception with the error message.
                     throw new ZilyException(header.Text);
+                case ZilyHeaderFlag.Connected:
+                    zs.IsOnline = true;
+                    break;
+                case ZilyHeaderFlag.Disconnected:
+                    zs.IsOnline = false;
+                    break;
                 default:
                     // Throw an exception because the response is unknown.
                     throw new ArgumentException("Invalid response.");

src/ZilyStream.cs

@@ -4,6 +4,8 @@
 using System.Linq;
 using Serilog;
 using System.Threading;
+using System.Security.Cryptography;
+using System.Runtime.InteropServices;
 
 namespace SAPTeam.Zily
 {
@@ -13,19 +15,19 @@ namespace SAPTeam.Zily
     public partial class ZilyStream : Stream
     {
         /// <summary>
-        /// Gets the protocol version.
+        /// Gets the underlying <see cref="System.IO.Stream"/>.
         /// </summary>
-        public static Version API = new Version(2, 0);
+        public Stream Stream { get; }
 
         /// <summary>
-        /// Gets the stream protocol version.
+        /// Gets the underlying <see cref="ISide"/> that parses the incoming responses.
         /// </summary>
-        public Version StreamVersion { get; private set; }
+        public ZilySide Side { get; }
 
         /// <summary>
-        /// Gets the underlying <see cref="System.IO.Stream"/>.
+        /// Gets or sets a value indicating whether this connection is online
         /// </summary>
-        public Stream Stream { get; }
+        public bool IsOnline { get; set; }
 
         private readonly UnicodeEncoding streamEncoding;
 
@@ -40,10 +42,13 @@ public partial class ZilyStream : Stream
         /// <param name="stream">
         /// An instance of <see cref="System.IO.Stream"/> with ability to read, write or both.
         /// </param>
+        /// <param name="side">
+        /// The <see cref="ZilySide"/> that parses the receiving responses.
+        /// </param>
         /// <param name="logger">
         /// The application's logger. by default it uses the <see cref="Log.Logger"/>.
         /// </param>
-        public ZilyStream(Stream stream, ILogger logger = null)
+        public ZilyStream(Stream stream, ZilySide side, ILogger logger = null)
         {
             if (logger == null)
             {
@@ -53,62 +58,12 @@ public ZilyStream(Stream stream, ILogger logger = null)
             logger.Debug("Initializing a new Zily session");
 
             Stream = stream;
+            Side = side;
             streamEncoding = new UnicodeEncoding();
             this.logger = logger;
         }
 
-        /// <summary>
-        /// Creates a header.
-        /// </summary>
-        /// <param name="flag">
-        /// The header flag.
-        /// </param>
-        /// <param name="length">
-        /// Length of bytes that will be sent.
-        /// </param>
-        /// <returns>
-        /// An array of the header bytes.
-        /// </returns>
-        public byte[] CreateHeader(HeaderFlag flag, int length)
-        {
-            if (length > ushort.MaxValue)
-            {
-                throw new ArgumentException("Length is too long.");
-            }
-
-            return !flag.IsParameterless() ? new byte[]
-            {
-                (byte)flag,
-                (byte)(length / 256),
-                (byte)(length & 255)
-            } : new byte[] { (byte)flag };
-        }
-
-        /// <summary>
-        /// Reads the header from the stream.
-        /// </summary>
-        /// <returns>
-        /// The header flag and Length of the text (argument) for that flag.
-        /// </returns>
-        public (HeaderFlag flag, int length) ReadHeader()
-        {
-            HeaderFlag flag;
-
-            while (true)
-            {
-                int data = ReadByte();
-                if (data != -1)
-                {
-                    flag = (HeaderFlag)data;
-                    break;
-                }
-            }
-
-            int length = flag.IsParameterless() ? 0 : Math.Max(0, (ReadByte() * 256) + ReadByte());
-
-            return (flag, length);
-        }
-
+        /*
         /// <summary>
         /// Receives sent data and then parses it.
         /// </summary>
@@ -319,23 +274,24 @@ public string ReadString(int length)
 
             return streamEncoding.GetString(buffer);
         }
+        */
 
         /// <summary>
-        /// Creates a header with the given flag and text then writes it beside the given <paramref name="text"/> to the stream.
+        /// Writes the given <see cref="ZilyHeader"/> to the stream.
         /// </summary>
-        /// <param name="flag">
-        /// The header flag.
-        /// </param>
-        /// <param name="text">
-        /// The text (argument) for the header flag.
+        /// <param name="header">
+        /// An instance of the <see cref="ZilyHeader"/> with outgoing data.
         /// </param>
-        public void WriteCommand(HeaderFlag flag, string text = null)
+        public void WriteCommand(ZilyHeader header)
         {
-            logger.Debug("Writing data with flag {flag} and message \"{text}\"", flag, text != null ? text.Replace("\n", "") : null);
-            byte[] body = text != null ? streamEncoding.GetBytes(text) : new byte[0];
-            byte[] header = CreateHeader(flag, body.Length);
-            byte[] buffer = header.Concat(body).ToArray();
+            if (!IsOnline)
+            {
+                throw new ZilyException("Zily is not connected.");
+            }
 
+            logger.Debug("Writing data with flag {flag} and message \"{text}\"", header.Flag, header.Text != null ? header.Text.Replace("\n", "") : null);
+
+            Byte[] buffer = header.ToByteArray();
             Write(buffer, 0, buffer.Length);
 
             if (Stream is MemoryStream)
@@ -351,19 +307,67 @@ public void WriteCommand(HeaderFlag flag, string text = null)
         }
 
         /// <summary>
-        /// Sends a command to the stream, then waits for receiving response and parses it.
+        /// Writes the given <see cref="ZilyHeader"/> to the stream, then waits for the response.
         /// </summary>
-        /// <param name="flag">
-        /// The header flag. Header flags are stored in the <see cref="HeaderFlag"/>.
+        /// <param name="header">
+        /// An instance of the <see cref="ZilyHeader"/> with outgoing data.
         /// </param>
-        /// <param name="text">
-        /// The text (argument) for the requested action or response to a request.
+        public void Send(ZilyHeader header)
+        {
+            WriteCommand(header);
+            ZilyHeader header2 = ZilyHeader.Parse(Stream);
+            Side.ParseHeader(header2);
+        }
+
+        /// <summary>
+        /// Listens to all incoming requests.
+        /// </summary>
+        /// <param name="cancellationToken">
+        /// A token for terminating the listener.
         /// </param>
-        public void Send(HeaderFlag flag, string text = null)
+        /// <param name="suppressLogger">
+        /// Determines whether the logger should be stopped during listening.
+        /// </param>
+        public void Listen(CancellationToken cancellationToken, bool suppressLogger = true)
+        {
+            logger.Information("Staring listener");
+            ILogger _logger = null;
+            if (suppressLogger)
+            {
+                _logger = logger;
+                logger = Serilog.Core.Logger.None;
+            }
+
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                try
+                {
+                    var header = ZilyHeader.Parse(Stream);
+                    Side.ParseHeader(header);
+                }
+                catch (IOException)
+                {
+                    break;
+                }
+            }
+
+            if (suppressLogger)
+            {
+                logger = _logger;
+            }
+
+            logger.Information("Listener has stopped");
+        }
+
+        /// <inheritdoc/>
+        public override void Close()
         {
-            WriteCommand(flag, text);
-            var header = ReadHeader();
-            ParseResponse(header);
+            logger.Information("Closing connection");
+            if (IsOnline)
+            {
+                WriteCommand(new ZilyHeader(Side.DisconnectFlag));
+                IsOnline = false;
+            }
         }
     }
 }