HttpHandler.cs

using MTSC.Common;
using MTSC.Common.Http;
using MTSC.Common.Http.ServerModules;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace MTSC.Server.Handlers
{
    public class HttpHandler : IHandler
    {
        private static string urlEncodedHeader = "application/x-www-form-urlencoded";
        private static string multipartHeader = "multipart/form-data";
        #region Fields
        List<IHttpModule> httpModules = new List<IHttpModule>();
        ConcurrentQueue<Tuple<ClientData,HttpMessage>> messageQueue = new ConcurrentQueue<Tuple<ClientData, HttpMessage>>();
        #endregion
        #region Constructors
        public HttpHandler()
        {
            
        }
        #endregion
        #region Public Methods
        public HttpHandler AddHttpModule(IHttpModule module)
        {
            this.httpModules.Add(module);
            return this;
        }
        public void QueueResponse(ClientData client, HttpMessage response)
        {
            messageQueue.Enqueue(new Tuple<ClientData, HttpMessage>(client, response));
        }
        #endregion
        #region Interface Implementation
        void IHandler.ClientRemoved(Server server, ClientData client)
        {
            
        }
        bool IHandler.HandleClient(Server server, ClientData client)
        {
            return false;
        }
        bool IHandler.HandleReceivedMessage(Server server, ClientData client, Message message)
        {
            HttpMessage httpMessage = new HttpMessage();
            HttpMessage responseMessage = new HttpMessage();
            httpMessage.ParseRequest(message.MessageBytes);
            if(httpMessage.ContainsHeader(HttpMessage.GeneralHeadersEnum.Connection) && 
                httpMessage[HttpMessage.GeneralHeadersEnum.Connection].ToLower() == "close")
            {
                responseMessage[HttpMessage.GeneralHeadersEnum.Connection] = "close";
                client.ToBeRemoved = true;
            }
            else
            {
                responseMessage[HttpMessage.GeneralHeadersEnum.Connection] = "keep-alive";
            }
            foreach(IHttpModule module in httpModules)
            {
                if(module.HandleRequest(server, this, client, httpMessage, ref responseMessage))
                {
                    break;
                }
            }
            QueueResponse(client, responseMessage);
            return false;
        }
        bool IHandler.HandleSendMessage(Server server, ClientData client, ref Message message)
        {
            return false;
        }
        bool IHandler.PreHandleReceivedMessage(Server server, ClientData client, ref Message message)
        {
            return false;
        }
        void IHandler.Tick(Server server)
        {
            while (messageQueue.Count > 0)
            {
                Tuple<ClientData, HttpMessage> tuple = null;
                if (messageQueue.TryDequeue(out tuple))
                {
                    server.QueueMessage(tuple.Item1, tuple.Item2.BuildResponse(true));
                }
            }
            foreach (IHttpModule module in httpModules)
            {
                module.Tick(server, this);
            }
        }
        #endregion
    }
}