Messages.cs

using System;
using System.Text;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;


namespace Common {

        /****************************************************************************/
        public class HTTPRequestMessage : Message, IContainsCallback {
                /* SPECIFICATION
                 * 
                 * Binary form:
                 * 
                 * int: Callback Receipt
                 * Bool: Has CHK
                 * { Byte 1..20: CHK (if null, ignore)}
                 * Byte 21..n: Encoded HTTP Request
                 */

                public override byte[] RawData {
                        get { return Serialise(); }
                }

                bool hasCHK;
                byte[] chk = null;
                public byte[] CHK {
                        set {
                                if (value == null) {
                                        hasCHK = false;
                                } else {
                                        hasCHK = true;
                                        chk = value;
                                }       
                        }
                        get { return chk; }
                }


                public int CallbackReceipt {
                        get { return callbackReceipt; }
                }
                public int callbackReceipt;
                public EncodedHTTPRequest encodedRequest;




                public HTTPRequestMessage() : base(MessageType.HTTPRequest) {
                        this.hasCHK = false;
                }
                public HTTPRequestMessage(byte[] src) : this(){
                        Deserialse(src);
                }

                public virtual byte[] Serialise() {
                        byte[] callbackBuffer = BitConverter.GetBytes(callbackReceipt);
                        byte[] hasChkBuffer = BitConverter.GetBytes(hasCHK);
                        byte[] encReqBuffer = encodedRequest.ToByteArray();
                        int bufferLength = callbackBuffer.Length + encReqBuffer.Length + hasChkBuffer.Length + (hasCHK ? chk.Length : 0);
                        byte[] buffer = new byte[bufferLength];
                        MemoryStream ms = new MemoryStream(buffer);
                        ms.Write(callbackBuffer, 0, callbackBuffer.Length);
                        ms.Write(hasChkBuffer, 0, hasChkBuffer.Length);
                        if (hasCHK) {
                                ms.Write(chk, 0, chk.Length);
                        }
                        ms.Write(encReqBuffer, 0, encReqBuffer.Length);
                        ms.Close();
                        if (buffer.Length != bufferLength) {
                                throw new ArithmeticException("Somebody can't count");
                        }
                        return buffer;
                }

                public virtual void Deserialse(byte[] src) {
                        int arrayPosition = 0;
                        callbackReceipt = BitConverter.ToInt32(src, arrayPosition);
                        arrayPosition += 4;
                        hasCHK = BitConverter.ToBoolean(src, arrayPosition);
                        arrayPosition += 1;
                        if (hasCHK) {
                                chk = new byte[20];
                                Array.Copy(src, arrayPosition, chk, 0, 20);
                                arrayPosition += 20;
                        } 
                        encodedRequest = new EncodedHTTPRequest(src, arrayPosition, src.Length - arrayPosition);
                }

                public HTTPRequestMessage(EncodedHTTPRequest encReq, int callbackRcpt, byte[] originalChk) : this() {
                        this.CHK = originalChk;
                        this.encodedRequest = encReq;
                        this.callbackReceipt = callbackRcpt;
                }
        
        }
        
        /****************************************************************************/
        public class HTTPResponseMessage : Message, IContainsCallback {
                public EncodedHTTPResponse encodedResponse;

                public override byte[] RawData {
                        
                        get {// assumes ints are 4 bytes
                                return Serialise();
                        }
                }

                int callbackReceipt; 

                public int CallbackReceipt {
                        get { return callbackReceipt; }
                }

                public HTTPResponseMessage() : base(MessageType.HTTPResponse) {}

                public HTTPResponseMessage(EncodedHTTPResponse encResponse, int callbackReceipt) : this() {
                        this.callbackReceipt = callbackReceipt;
                        this.encodedResponse = encResponse;
                }
                public HTTPResponseMessage(byte[] src) : this() {
                        Deserialise(src);
                }

                public virtual void Deserialise(byte[] src) {
                        callbackReceipt = BitConverter.ToInt32(src, 0);
                        encodedResponse = new EncodedHTTPResponse(src, 4, src.Length - 4);
                }

                public virtual byte[] Serialise() {
                        byte[] callbackBuffer = BitConverter.GetBytes(callbackReceipt);
                        byte[] encRespBuffer = encodedResponse.Serialise();
                        byte[] buffer = new byte[callbackBuffer.Length + encRespBuffer.Length];
                        Array.Copy(callbackBuffer, buffer, callbackBuffer.Length);
                        Array.Copy(encRespBuffer, 0, buffer, callbackBuffer.Length, encRespBuffer.Length);
                        return buffer;
                }
        }
        /****************************************************************************/

        public class NoChangeMessage : Message, IContainsCallback {
                public byte[] chk;
                public int callbackReceipt;
                public HTTPResponseHeader responseHeaders;
                private bool HasChk {
                        get { return chk != null; }
                }

                public int CallbackReceipt {
                        get { return callbackReceipt; }
                }
                public override byte[] RawData {
                        get {
                                return Serialise();
                        }
                }

                public NoChangeMessage(byte[] chk, int callbackReceipt, string respHeader) : base(MessageType.NoChange) {
                        this.chk = chk;
                        this.callbackReceipt = callbackReceipt;
                        this.responseHeaders = new HTTPResponseHeader(respHeader);
                }

                public NoChangeMessage() : base(MessageType.NoChange) {}

                public NoChangeMessage(byte[] src) : base(MessageType.NoChange) {
                        Deserialise(src);
                }

                public virtual void Deserialise(byte[] src) {
                        int currentPos = 0;
                        chk = new byte[20];
                        callbackReceipt = BitConverter.ToInt32(src, currentPos);
                        currentPos += 4;
                        int headerLen = BitConverter.ToInt32(src, currentPos);
                        currentPos += 4;
                        responseHeaders = new HTTPResponseHeader(Encoding.ASCII.GetString(src, currentPos, headerLen));
                        currentPos += headerLen;
                        bool hasChkTemp = BitConverter.ToBoolean(src, currentPos);
                        currentPos += 1; // bool is one byte
                        if (hasChkTemp) {
                                Array.Copy(src, currentPos, chk, 0, 20);
                        }
                }

                public virtual byte[] Serialise() {
                        int currentPos = 0;
                        byte[] callbackBuffer = BitConverter.GetBytes(callbackReceipt);
                        byte[] respBuffer = Encoding.ASCII.GetBytes(responseHeaders.rawString);
                        byte[] buffer = new byte[callbackBuffer.Length + BitConverter.GetBytes(respBuffer.Length).Length + respBuffer.Length + 20 + BitConverter.GetBytes(HasChk).Length];
                        Array.Copy(callbackBuffer, buffer, callbackBuffer.Length); // callback int
                        currentPos += callbackBuffer.Length;
                        Array.Copy(BitConverter.GetBytes(respBuffer.Length), 0, buffer, currentPos, BitConverter.GetBytes(respBuffer.Length).Length); // response header length
                        currentPos += BitConverter.GetBytes(respBuffer.Length).Length;
                        Array.Copy(respBuffer, 0, buffer, currentPos, respBuffer.Length); // response headers
                        currentPos += respBuffer.Length;
                        Array.Copy(BitConverter.GetBytes(HasChk), 0, buffer, currentPos, BitConverter.GetBytes(HasChk).Length); // has chk?
                        currentPos += BitConverter.GetBytes(HasChk).Length;
                        if (HasChk) {
                                Array.Copy(chk, 0, buffer, currentPos, 20); // chk
                        }
                        return buffer;
                }
        }       
        /****************************************************************************/
        public class CacheIndexMessage : Message{
                public CacheIndex index;

                public override byte[] RawData {
                        get { return index.Serialise(); }

                }
                public CacheIndexMessage(CacheIndex index) : base(MessageType.CacheIndex){
                        this.index = index;
                }

                public CacheIndexMessage(byte[] src) : base(MessageType.CacheIndex) {
                        this.index = CacheIndex.Deserialise(src);
                }
        }

        /****************************************************************************/
        public interface ICacheUpdateMessage {
                Uri RequestUri {
                        get;
                        set;
                }
        }
        /****************************************************************************/
        public class CacheUpdateHTTPResponseMsg : HTTPResponseMessage, ICacheUpdateMessage {
                private Uri requestUri;
                public Uri RequestUri {
                        get { return requestUri; }
                        set { requestUri = value; }
                }

                public CacheUpdateHTTPResponseMsg(Uri requestUri, EncodedHTTPResponse encodedResponse) : base(encodedResponse, 0) {
                        this.Type = MessageType.CacheUpdateHTTPResponse;
                        this.RequestUri = requestUri;
                }

                public CacheUpdateHTTPResponseMsg(byte[] src) {
                        this.Type = MessageType.CacheUpdateHTTPResponse;
                        this.Deserialise(src);
                }

                public override void Deserialise(byte[] src) {
                        long uriLength = BitConverter.ToInt64(src, 0); // 8 bytes long
                        byte[] uriBuffer = new byte[uriLength];
                        byte[] baseBuffer = new byte[src.Length - uriLength - 8];
                        IFormatter formatter = new BinaryFormatter();
                        Array.Copy(src, 8, uriBuffer, 0, (int)uriLength);
                        MemoryStream uriStream = new MemoryStream(uriBuffer);
                        requestUri = (Uri)formatter.Deserialize(uriStream);
                        uriStream.Close();
                        Array.Copy(src, 8 + (int)uriLength, baseBuffer, 0, baseBuffer.Length);
                        base.Deserialise(baseBuffer);
                }

                public override byte[] Serialise() {
                        MemoryStream uriStream = new MemoryStream();
                        MemoryStream resultStream = new MemoryStream();
                        IFormatter formatter = new BinaryFormatter();

                        formatter.Serialize(uriStream, RequestUri);
                        resultStream.Write(BitConverter.GetBytes(uriStream.Length), 0, BitConverter.GetBytes(uriStream.Length).Length);
                        uriStream.Seek(0, SeekOrigin.Begin);
                        uriStream.WriteTo(resultStream);
                        MemoryStream baseStream = new MemoryStream(base.Serialise());
                        baseStream.Seek(0, SeekOrigin.Begin);
                        baseStream.WriteTo(resultStream);
                        byte[] resultBig = resultStream.GetBuffer();
                        byte[] result = new byte[resultStream.Length];
                        Array.Copy(resultBig, result, (int)resultStream.Length);
                        resultStream.Close();
                        baseStream.Close();
                        uriStream.Close();
                        return result;
                }
        }
        /****************************************************************************/
        public class CacheUpdateNoChangeMsg: NoChangeMessage, ICacheUpdateMessage {
                private Uri requestUri;
                public Uri RequestUri {
                        get { return requestUri; }
                        set { requestUri = value; }
                }

                public CacheUpdateNoChangeMsg(Uri requestUri, byte[] chk, string responseHeader) : base(chk, 0, responseHeader) {
                        this.Type = MessageType.CacheUpdateNoChange;
                        this.RequestUri = requestUri;
                }

                public CacheUpdateNoChangeMsg(byte[] src) {
                        this.Type = MessageType.CacheUpdateNoChange;
                        this.Deserialise(src);
                }

                public override void Deserialise(byte[] src) {
                        long uriLength = BitConverter.ToInt64(src, 0); // 8 bytes long
                        byte[] uriBuffer = new byte[uriLength];
                        byte[] baseBuffer = new byte[src.Length - uriLength - 8];
                        IFormatter formatter = new BinaryFormatter();
                        Array.Copy(src, 8, uriBuffer, 0, (int)uriLength);
                        MemoryStream uriStream = new MemoryStream(uriBuffer);
                        requestUri = (Uri)formatter.Deserialize(uriStream);
                        uriStream.Close();
                        Array.Copy(src, 8 + (int)uriLength, baseBuffer, 0, baseBuffer.Length);
                        base.Deserialise(baseBuffer);
                }

                public override byte[] Serialise() {
                        MemoryStream uriStream = new MemoryStream();
                        MemoryStream resultStream = new MemoryStream();
                        IFormatter formatter = new BinaryFormatter();

                        formatter.Serialize(uriStream, RequestUri);
                        resultStream.Write(BitConverter.GetBytes(uriStream.Length), 0, BitConverter.GetBytes(uriStream.Length).Length);
                        uriStream.Seek(0, SeekOrigin.Begin);
                        uriStream.WriteTo(resultStream);
                        MemoryStream baseStream = new MemoryStream(base.Serialise());
                        baseStream.Seek(0, SeekOrigin.Begin);
                        baseStream.WriteTo(resultStream);
                        byte[] resultBig = resultStream.GetBuffer();
                        byte[] result = new byte[resultStream.Length];
                        Array.Copy(resultBig, result, (int)resultStream.Length);
                        resultStream.Close();
                        baseStream.Close();
                        uriStream.Close();
                        return result;
                }
        }
        /****************************************************************************/
        public class CacheIndexRequestMessage : Message {
                public override byte[] RawData {
                        get { return new byte[0]; }
                }
                public CacheIndexRequestMessage(ushort requestIndexFrom) : base(MessageType.CacheIndexRequest) {
                        Destination = requestIndexFrom;
                }

                public CacheIndexRequestMessage(byte[] src) : base(MessageType.CacheIndexRequest) {}

        }

}

---