hudou/MSHO.Collection.Service/MSHO.Collection.Service/IO/IOServer.Partial.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MSHO.Collection.Service.IO
{
    partial class IOServer
    {
        private object m_lock_client = new object();
        private Dictionary<string, Task> m_ClientTask = new Dictionary<string, Task>();

        public void StartClientTask(System.Net.Sockets.Socket client) {
            var task = new System.Threading.Tasks.Task(ProcessClientMsg, client);
            task.Start();
        }

        private void ProcessClientMsg(object state) {
            var client = state as System.Net.Sockets.Socket;

            try
            {
                do
                {
                    var msg = ReceiveMsg(client);
                    if (msg == null)
                    {
#if DEBUG
                        Console.WriteLine("msg == null");
#endif
                        break;
                    }
                    else if (msg.BadMsg)
                    {
                        SendMsg(client, new Message(new Msg()
                        {
                            Content = "错误的请求消息"
                        }));
                    } else if(msg.Length > (long)0) {
                        var mm = Msg.ParseMsg(msg);
                        if (mm != null)
                        {
                            switch (mm.MessageType)
                            {
                                case MessageTypeEnum.Connect:
                                    ProcessConnectMsg(client, mm);
                                    break;

                                case MessageTypeEnum.Heart:
                                    ProcessHeartMsg(client, mm);
                                    break;

                                case MessageTypeEnum.ReportData:
                                    ProcessReportDataMsg(client, mm);
                                    break;

                                case MessageTypeEnum.ErrorData:
                                    Process_Exception(client, mm);
                                    break;

                                case MessageTypeEnum.UploadFile:
                                    Process_UploadFile(client, mm);
                                    break;

                                case MessageTypeEnum.GetUploadFile:
                                    Process_GetUploadFile(client, mm);
                                    break;
                            }
                        }
                        else
                        {
                            SendMsg(client, new Message(new Msg()
                            {
                                Content = "错误的请求消息"
                            }));
                        }
                    }
                } while (m_Running);
            }
            catch (Exception ex)
            {
                MSHO.Collection.DataAccess.MSHOService.Instance.SaveSystemLog("MSHO.Collection.Service", "ProcessClientMsg", ex);
            }
            finally
            {
                if (client != null)
                {
                    try
                    {
#if DEBUG
                        Console.WriteLine(".............................................断开客户端连接");
#endif
                        client.Close();
                    }
                    catch { }
                }
            }
        }

        private void ProcessReportDataMsg(System.Net.Sockets.Socket client, Msg data)
        {
#if DEBUG
            Console.WriteLine("收到数据，开始处理");
            var watch = new System.Diagnostics.Stopwatch();
            watch.Start();
#endif
            var msg = new DataReportRespMsg();
            msg.ClientCode = data.ClientCode;

            var data_report = data as DataReportMsg;
            if (data_report != null) {
                switch (data_report.DataType) {
                    case MSHO.Collection.DataAccess.ClientModels.ClientDataType.Bus_Weighting:
                        Process_Bus_Weighting(msg, data_report);
                        break;

                    case MSHO.Collection.DataAccess.ClientModels.ClientDataType.Access_Weighting:
                        Process_Access_Weighting(msg, data_report);
                        break;

                    case MSHO.Collection.DataAccess.ClientModels.ClientDataType.Kdtc_Weighting:
                        Process_Kdtc_Weighting(msg, data_report);
                        break;

                    case MSHO.Collection.DataAccess.ClientModels.ClientDataType.SQL2000_DiBangData_Weighting:
                        Process_SQL2000_DiBangData_Weighting(msg, data_report);
                        break;

                    case MSHO.Collection.DataAccess.ClientModels.ClientDataType.SQL2000_oreManageDBCli_Weighting:
                        Process_SQL2000_oreManageDBCli_Weighting(msg, data_report);
                        break;

                    case MSHO.Collection.DataAccess.ClientModels.ClientDataType.SQL2000_oreManageDBCli_2_Weighting:
                        Process_SQL2000_oreManageDBCli_2_Weighting(msg, data_report);
                        break;

                    case MSHO.Collection.DataAccess.ClientModels.ClientDataType.SQL2000_oreManageDBCli_3_Weighting:
                        Process_SQL2000_oreManageDBCli_3_Weighting(msg, data_report);
                        break;

                    case MSHO.Collection.DataAccess.ClientModels.ClientDataType.LowSpeedNew_Weighting:
                        Process_LowSpeedNew_Weighting(msg, data_report);
                        break;
                }
            }
            
            SendMsg(client, new Message(msg));

#if DEBUG
            watch.Stop();
            Console.WriteLine("处理完成SaveWeighting({0}): {1}", msg.ClientCode, watch.Elapsed);
#endif
        }


        private void ProcessConnectMsg(System.Net.Sockets.Socket client, Msg connect) {
#if DEBUG
            Console.WriteLine("{0}获取配置", connect.ClientCode);
#endif
            var config = MSHO.Collection.DataAccess.MSHOService.Instance.GetCollectConfigByCode(connect.ClientCode);
            if (config != null) {
                var msg = new ConnectRespMsg();
                msg.ClientCode = connect.ClientCode;
                var serverConfig = config.ToServerConfig();
                if (serverConfig != null) {
                    serverConfig.LastSourceID = config.LastSourceID;
                    serverConfig.LastSourceTime = config.LastSourceTime;
                    msg.Content = serverConfig.ToJson();

                    SendMsg(client, new Message(msg));
                    return;
                }
            }


            SendMsg(client, new Message(new Msg()
            {
                Content = "未知的采集编号"
            }));
        }

        private void ProcessHeartMsg(System.Net.Sockets.Socket client, Msg heart)
        {
            var msg = new HeartRespMsg();
            msg.ClientCode = heart.ClientCode;
            msg.Time = DateTime.Now;
            MSHO.Collection.DataAccess.MSHOService.Instance.UpdateDeviceStatus(heart.ClientCode);
#if DEBUG
            Console.WriteLine("心跳消息：{0}", heart.ClientCode);
#endif
            SendMsg(client, new Message(msg));
        }

        private void Process_UploadFile(System.Net.Sockets.Socket client, Msg data) {
#if DEBUG
            Console.WriteLine("开始处理文件...");
#endif
            var msg = new UploadFileMsgRespMsg();
            msg.ClientCode = data.ClientCode;

            var uploadFileMsg = data as UploadFileMsg;
            if (uploadFileMsg != null) {
                if (uploadFileMsg.WeightingID > 0)
                {
                    if (!string.IsNullOrEmpty(uploadFileMsg.FileStreamBase64))
                    {
                        msg.Result = MSHO.Collection.DataAccess.MSHOService.Instance.SaveWeightingFile(uploadFileMsg.ID, uploadFileMsg.WeightingID, uploadFileMsg.FileStreamBase64, uploadFileMsg.BufferLength);
                    }
                    else
                    {
                        msg.Result = true;
                    }
                }
            }

            SendMsg(client, new Message(msg));

#if DEBUG
            Console.WriteLine("...............处理文件完成");
#endif
        }

        private void Process_GetUploadFile(System.Net.Sockets.Socket client, Msg data)
        {
            var msg = new GetUploadFileMsgRespMsg();
            msg.ClientCode = data.ClientCode;

            MSHO.Collection.DataAccess.Models.CollectConfig clientConfig = null;
            if (m_CollectConfigs.ContainsKey(msg.ClientCode))
            {
                clientConfig = m_CollectConfigs[msg.ClientCode];
            }
            if (clientConfig == null)
            {
                clientConfig = MSHO.Collection.DataAccess.MSHOService.Instance.GetCollectConfigByCode(msg.ClientCode);
            }

            msg.WeightingFiles = MSHO.Collection.DataAccess.MSHOService.Instance.GetWeightingFileByDeviceID(clientConfig.DeviceID).Take(10).ToList();

            SendMsg(client, new Message(msg));
        }

        private Message ReceiveMsg(System.Net.Sockets.Socket client)
        {
            try
            {
                var msg = new Message();
                var buffer = new byte[sizeof(long)];
                if (client.Connected)
                {
                    var len = client.Receive(buffer, 0, buffer.Length, System.Net.Sockets.SocketFlags.None);
                    if (len > 0 && len == sizeof(long))
                    {
                        var length = Helper.BytesToLong(buffer);
#if DEBUG
                        if (length > 0)
                        {
                            Console.WriteLine("开始接收消息({0})", length);
                        }
#endif

                        if (length > 0)
                        {
                            var stream = new System.IO.MemoryStream();
                            while (stream.Length < length)
                            {
                                buffer = new byte[length];
                                len = client.Receive(buffer, 0, buffer.Length, System.Net.Sockets.SocketFlags.None);
                                if (len > 0)
                                {
                                    stream.Write(buffer, 0, len);
                                }
                                else
                                {
                                    msg.BadMsg = true;
                                    break;
                                }
                            }

                            msg.Write(stream.ToArray());
                        }
#if DEBUG
                        if (msg.BadMsg == false && msg.Length > 0)
                        {
                            Console.WriteLine("................消息接收完成({0})", msg.Length);
                        }
#endif
                    }
                    else {
                        msg.BadMsg = true;
                    }
                }

                return msg;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return null;
        }

        private void SendMsg(System.Net.Sockets.Socket client, Message msg)
        {
            if (m_Running && client != null)
            {
                if (client.Connected)
                {
                    var buffer = msg.ToBuffer();
                    client.Send(buffer, 0, buffer.Length, System.Net.Sockets.SocketFlags.None);
                }
            }
        }


    }
}