MARKUS

using System;

using System.ComponentModel;

using System.Runtime.Remoting;

using System.Runtime.Remoting.Channels;

using System.Runtime.Remoting.Channels.Tcp;

using System.Threading;

using System.Data.SqlClient;

using System.Linq;

using System.Collections.Generic;

using System.Diagnostics;

using System.Threading.Tasks;

using System.Collections;

using DeepViewDataModel.DataModel;

using DeepViewDataModel.Common;

using System.IO;

using System.Net;

using IConverterPDF;

using DZConverterLib;

using System.Text;

using ConverterStation.Remoting;

using System.Diagnostics.CodeAnalysis;

using System.Runtime.InteropServices;

using System.Security;

using PropertiesType;

using DeepView.Toolkit.GuidGenerator;

using DZConverterLib.Event;

namespace ConverterStation.Service

{

    public class ConverterService : InterfaceConverterPDF, IDisposable

    {

        #region Properties

        public TcpChannel channel { get; set; }

        public ServiceEventLog _log { get; set; }

        private ConverterServiceType SeriviceType { get; set; }

        private Guid ServiceID { get; set; }

        private string _serviceID { get; set; }

        private Guid _ServiceID { get; set; }

        private Thread _ConverterPdfThread { get; set; }

        private Queue<CONVERTER_DOC> _WorkItems { get; set; }

        private List<CONVERTER_DOC> _thread { get; set; }

        private List<ServiceItem> LstService { get; set; }

        public int remotingPort { get; set; }

        public string hostName { get; set; }

        #endregion

        #region inheritance property

        private int _MultiProcessCount;

        public int MultiProcessCount

        {

            get

            {

                if (_MultiProcessCount == 0)

                    return 1;

                else

                    return _MultiProcessCount;

            }

            set

            {

                using (DeepView_Entity _deepview = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

                {

                    _serviceID = ServiceID.ToString();

                    var _service = _deepview.SERVICE_PROPERTIES.Where(s => s.ID == _serviceID);

                    if (_service.Count() > 0)

                    {

                        _service.First().PROCESS_COUNT = value;

                        _deepview.SaveChanges();

                        _MultiProcessCount = value;

                    }

                }

            }

        }

        #endregion

        #region inheritance Method

        public void Dispose()

        {

            if (channel != null)

            {

                ChannelServices.UnregisterChannel(channel);

            }

        }

        public ConverterPDFResult Notify(string ProjectNo, Guid ConverterID)

        {

            try

            {

                using (DeepView_Entity _Entity = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

                {

                    _serviceID = ConverterID.ToString();

                    var _result = from Converter in _Entity.CONVERTER_DOC

                                  where Converter.ID == _serviceID

                                  select Converter;

                    StartConverterPDFProcess(_result.ToList());

                }

            }

            catch (Exception ex)

            {

                SetError(ConverterID, "Notify error 서비스를 시작할 수 없습니다.", ex.ToString(), 0);

                return new ConverterPDFResult { ConverterID = ConverterID, ProjectNo = ProjectNo, Exception = ex.ToString() };

            }

            return new ConverterPDFResult { ConverterID = ConverterID, ProjectNo = ProjectNo };

        }

        public Guid[] RunningProcessID()

        {

            string[] _temp = _thread.Select(t => t.ID).ToArray();

            Guid[] _return = new Guid[_temp.Length];

            for (int i = 0; i < _temp.Length; i++ )

            {

                _return[i] = Guid.Parse(_temp[i]);

            }

            return _return;

            //return _thread.Select(t => Guid.Parse(t.ID)).ToArray();

        }

        public ServiceInfo ServiceInfomation()

        {

            ServiceInfo _info = new ServiceInfo();

            StringBuilder bl = new StringBuilder();

            try

            {

                _info.ServiceUri = ServiceUri();

            }

            catch (Exception ex)

            {

                bl.AppendLine("<ServiceUri Error>");

                bl.AppendLine(ex.ToString());

                bl.AppendLine("_________________________");

            }

            try

            {

                _info.ServiceID = ServiceID;

            }

            catch (Exception ex)

            {

                bl.AppendLine("ServiceID Error :");

                bl.AppendLine("service ID : " + ServiceID.ToString());

                bl.AppendLine(ex.ToString());

                bl.AppendLine("_________________________");

            }

            try

            {

                _info.StorageInfo = TileSorceStorageInfomation(); ;

            }

            catch (Exception ex)

            {

                bl.AppendLine("TileSorceStorageInfomation Error :");

                bl.AppendLine(ex.ToString());

                bl.AppendLine("_________________________");

            }

            if (bl.Length > 0)

                _info.Exception = bl.ToString();

            return _info;

        }

        public TileSorceStorageInfo[] TileSorceStorageInfomation()

        {

            List<TileSorceStorageInfo> _info = new List<TileSorceStorageInfo>();

            string _TestDir = "createTestDir";

            using (DeepView_Entity _deepview = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

            {

                var _storage = (from proper in _deepview.PROPERTIES

                                where proper.TYPE == PropertiesType.PropertiesType.Const_TileSorceStorage

                                group proper by proper.VALUE into p

                                select p.Key

                                ).ToList();

                _storage.ForEach(s =>

                {

                    TileSorceStorageInfo _storageInfo = new TileSorceStorageInfo();

                    _storageInfo.FolderName = s;

                    _storageInfo.FreeSpace = FreeSpace(s);

                    try

                    {

                        DirectoryInfo _Dirinfo = new DirectoryInfo(s);

                        var _dir = _Dirinfo.EnumerateDirectories().Where(d => d.Name == _TestDir);

                        if (_dir.Count() == 0)

                            _Dirinfo = _Dirinfo.CreateSubdirectory("createTestDir");

                        else

                            _Dirinfo = _dir.First();

                        if (_Dirinfo.Exists)

                            _Dirinfo.Delete(true);

                        _Dirinfo = new DirectoryInfo(_Dirinfo.FullName);

                        if (!_Dirinfo.Exists)

                            _storageInfo.Access = true;

                    }

                    catch (Exception ex)

                    {

                        throw;

                    }

                    _info.Add(_storageInfo);

                });

            }

            return _info.ToArray();

        }

        public bool ServiceOn(Guid ServiceID)

        {

            try

            {

                SetSubPassService();

            }

            catch (Exception ex)

            {

                SendError("Service On Error", ex.ToString(), 0);

            }

            return true;

        }

        #endregion

        #region Constructors

        public ConverterService(ServiceEventLog eventLog)

        {

            var IsServerSet = SetServerSetting();

            _log = eventLog;

            if (_WorkItems == null)

                _WorkItems = new Queue<CONVERTER_DOC>();

            if (_thread == null)

                _thread = new List<CONVERTER_DOC>();

            if (IsServerSet)

            {

                InitWork();

            }

            else

                _log.Write("Converter Service 호스트 이름을 찾을 수 없습니다.");

        }

        #endregion

        #region Event of DZConverter

        void dz_EndConverter(object sender, EndConverterEventArgs e)

        {

            var _T = _thread.Where(t => t.ID == (sender as DZConverterLib.DZConverter).ConverterItem.ID);

            if (_T.Count() > 0)

            {

                Guid _id = Guid.Parse(_T.First().ID);

                SetConveterState(_id, IConverterPDF.ConverterStatus.Success);

                _thread.Remove((sender as DZConverterLib.DZConverter).ConverterItem);

                (sender as DZConverterLib.DZConverter).ConverterMakeError -= new EventHandler<MakeConverterErrorArgs>(dz_ConverterMakeError);

                (sender as DZConverterLib.DZConverter).EndConverter -= new EventHandler<EndConverterEventArgs>(dz_EndConverter);

                (sender as DZConverterLib.DZConverter).Dispose();

            }

            else

            {

                SetError(Guid.Parse((sender as DZConverterLib.DZConverter).ConverterItem.ID), "Thread Count 0", "Thread가 없습니다", 0);

            }

            if (_WorkItems.Count() == 0 && this.SeriviceType == ConverterServiceType.Main)

                ReAttemptConverterPDF();

        }

        void dz_ConverterMakeError(object sender, MakeConverterErrorArgs e)

        {

            SetError(e.ConverterID, e.ErrorCode, e._Exception, e.Level);

            try

            {

                if (e.ThreadStop)

                {

                    _thread.Remove((sender as DZConverterLib.DZConverter).ConverterItem);

                    (sender as DZConverterLib.DZConverter).ConverterMakeError -= new EventHandler<MakeConverterErrorArgs>(dz_ConverterMakeError);

                    (sender as DZConverterLib.DZConverter).EndConverter -= new EventHandler<EndConverterEventArgs>(dz_EndConverter);

                    (sender as DZConverterLib.DZConverter).Dispose();

                }

            }

            catch (Exception ex)

            {

                SetError(e.ConverterID, "dz_ConverterMakeError에서 Thread 제거 불가", ex.ToString(), 0);

            }

        }

        #endregion

        #region Method

        private void CreateServerSetting()

        {

            hostName = System.Environment.MachineName;

            using (DeepView_Entity de = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

            {

                var serviceProperties = de.SERVICE_PROPERTIES.Where(host => host.HOST_NAME == hostName);

                if (serviceProperties.Count() == 0)

                {

                    SERVICE_PROPERTIES serviceProperty = new SERVICE_PROPERTIES();

                    serviceProperty.ID = GuidGenerator.GetUniqueGuid().ToString();

                    serviceProperty.HOST_NAME = hostName;

                    IPAddress ipaddress = Dns.Resolve(Dns.GetHostName()).AddressList[0];

                    serviceProperty.SERVICE_ADDRESS = ipaddress.ToString();

                    serviceProperty.SERVICE_PORT = Properties.Settings.Default.RemotingPort;

                    serviceProperty.PROCESS_COUNT = Properties.Settings.Default.MultipleConverterCount;

                    serviceProperty.SERVICET_TYPE = (int)PropertiesType.ConverterServiceType.Sub;

                    de.SERVICE_PROPERTIES.AddObject(serviceProperty);

                    de.SaveChanges();

                }

            }

        }

        public bool SetServerSetting()

        {

            bool SettingCompleted = false;

            hostName = System.Environment.MachineName;

            try

            {

                using (DeepView_Entity de = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

                {

                    var serviceProperties = de.SERVICE_PROPERTIES.Where(host => host.HOST_NAME == hostName);

                    if (serviceProperties.Count() > 0)

                    {

                        var serviceProperty = serviceProperties.First();

                        remotingPort = int.Parse(serviceProperty.SERVICE_PORT.ToString());

                        ServiceID = Guid.Parse(serviceProperty.ID);

                        MultiProcessCount = serviceProperty.PROCESS_COUNT;

                        SeriviceType = (ConverterServiceType)serviceProperty.SERVICET_TYPE;

                    }

                    else

                    {

                        CreateServerSetting();

                    }

                    SettingCompleted = true;

                }

            }

            catch (Exception ex)

            {

                SettingCompleted = false;

                _log.Write("ServerSetting Error : " + ex.ToString());

            }

            return SettingCompleted;

        }

        private static long FreeSpace(string folderName)

        {

            if (string.IsNullOrEmpty(folderName))

            {

                throw new ArgumentNullException("folderName");

            }

            if (!folderName.EndsWith("\\"))

            {

                folderName += '\\';

            }

            long free = 0, dummy1 = 0, dummy2 = 0;

            if (GetDiskFreeSpaceEx(folderName, ref free, ref dummy1, ref dummy2))

            {

                return free;

            }

            else

            {

                return -1;

            }

        }

        public void InitWork()

        {

            Thread _initThread = new Thread(new ThreadStart(Init));

            _initThread.Start();

        }

        public void InitializeProcess()

        {

            using (DeepView_Entity _deepview = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

            {

                _serviceID = ServiceID.ToString();

                var _converterItems = _deepview.CONVERTER_DOC.Where(c => c.SERVICE_ID == _serviceID &&

                                                                        c.STATUS != (int)ConverterStatus.Success &&

                                                                        c.RECONVERTER < 3);

                foreach (var item in _converterItems)

                {

                    item.STATUS = 0;

                    item.RECONVERTER = 1;

                    item.SERVICE_ID = null;

                }

                if (_converterItems.Count() > 0)

                    _deepview.SaveChanges();

            }

        }

        public void Init()

        {

            try

            {

                channel = new TcpChannel(remotingPort);

                ChannelServices.RegisterChannel(channel, false);

                RemotingConfiguration.RegisterWellKnownServiceType(typeof(RemConverterPDFObject), "remConverterPDF", WellKnownObjectMode.Singleton);

                IConverterPDF.Cache.Attach(this);

                _log.Write("Notice <Service Infomation>");

                _log.Write("Port" + remotingPort.ToString());

                _log.Write("HostName" + hostName);

                _log.Write("Service ID :" + ServiceID.ToString());

                _log.Write("Service Type :" + SeriviceType.ToString());

                _log.Write("Service Host :" + hostName);

                if (hostName != null)

                {

                    InitializeProcess();

                    foreach (var item in TileSorceStorageInfomation())

                    {

                        _log.Write("Storage(" + item.FolderName + ") " +

                                  (item.FreeSpace / 1024f) / 1024f / 1024f + "GB");

                    }

                    //0번일 때

                    if (this.SeriviceType == ConverterServiceType.Main)

                    {                               

                        //Sub 

                        _log.Write("SetSubPassService :" + SetSubPassService());

                        ReAttemptConverterPDF();

                    }

                    else

                    {

                        List<SERVICE_PROPERTIES> _service = new List<SERVICE_PROPERTIES>();

                        using (DeepView_Entity _deepview = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

                        {

                            _service = _deepview.SERVICE_PROPERTIES.ToList();

                            _log.Write("_service :" + _service.First().ToString());

                            var _mainService = _service.Where(s => s.HOST_NAME == hostName &&

                                            (ConverterServiceType)s.SERVICET_TYPE == ConverterServiceType.Main);

                            _log.Write("_mainService_count :" + _mainService.Count());

                            if (_mainService.Count() > 0)

                            {

                                var mainservice = _mainService.First();

                                try

                                {

                                    RemConverterPDFObject rem = (RemConverterPDFObject)Activator.GetObject(typeof(RemConverterPDFObject),

                                                               "tcp://" + mainservice.SERVICE_ADDRESS + ":"

                                                               + mainservice.SERVICE_PORT + "/remConverterPDF");

                                    if (rem != null)

                                        rem.ServiceOn(ServiceID); //SetSubPassService() 메서드 호출

                                }

                                catch (Exception ex)

                                {

                                    _log.Write("Main Connection Error  : " + ex.ToString());

                                }

                            }

                        }

                    }

                }

                else

                {

                    _log.Write("Converter Service : " + hostName + "데이터베이스에서 호스트 정보를 찾을 수 없습니다.");

                }

                //SendError("Start Service Info.", _ServiceStartRpt.ToString(), 0);

            }

            catch (Exception ex)

            {

                if (_log != null)

                    _log.Write("RemConverterStation" + "02156");

            }

        }

        private Uri ServiceUri()

        {

            Uri _result = null;

            try

            {

                if (channel.ChannelData != null)

                    if (channel.ChannelData.GetType() == typeof(ChannelDataStore))

                    {

                        var _uris = (channel.ChannelData as ChannelDataStore).ChannelUris;

                        if (_uris.Count() > 0)

                            _result = new Uri(_uris[0]);

                    }

            }

            catch (Exception)

            {

                new Exception("service Uri Eorror");

            }

            return _result;

        }

        public string SetSubPassService()

        {

            if (LstService == null) LstService = new List<ServiceItem>();

            StringBuilder _ServiceStartRpt = new StringBuilder();

            List<SERVICE_PROPERTIES> _service = new List<SERVICE_PROPERTIES>();

            using (DeepView_Entity _deepview = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

            {

                //_service = _deepview.ServiceProperties.Where(f => f.HostName.ToLower() 

                //                                            == hostName.ToLower()).ToList();

                _service = _deepview.SERVICE_PROPERTIES.ToList();

            }

            _serviceID = ServiceID.ToString();

            //강인구

            _service.ForEach(s =>

            {

                _ServiceID = Guid.Parse(s.ID);

                if (s.ID != _serviceID && LstService.Where(ser => ser.ServiceID == _ServiceID).Count() == 0)

                {

                    System.Runtime.Remoting.Channels.IChannel _ch = ChannelServices.GetChannel("tcp");

                    if (_ch == null)

                    {

                        TcpChannel chan = new TcpChannel();

                        ChannelServices.RegisterChannel(chan, false);

                    }

                    // Create an instance of the remote object

                    RemConverterPDFObject rem = (RemConverterPDFObject)Activator.GetObject(typeof(RemConverterPDFObject),

                                                                "tcp://" + s.SERVICE_ADDRESS + ":" + s.SERVICE_PORT + "/remConverterPDF");

                    try

                    {

                        rem.MultiProcessCount = s.PROCESS_COUNT;

                        var _Info = rem.ServiceInfomation();

                        _ServiceStartRpt.AppendLine("");

                        _ServiceStartRpt.AppendLine("Service Type :" + ((ConverterServiceType)s.SERVICET_TYPE).ToString());

                        _ServiceStartRpt.AppendLine("Service ID :" + s.ID.ToString());

                        _ServiceStartRpt.AppendLine("Service Address :" + _Info.ServiceUri);

                        foreach (var item in _Info.StorageInfo)

                        {

                            _ServiceStartRpt.AppendLine("Storage(" + item.FolderName + ") Access:" + item.Access.ToString());

                        }

                        var _runningItem = rem.RunningProcessID();

                        _ServiceStartRpt.AppendLine("");

                        _ServiceStartRpt.AppendLine("Running Item");

                        _runningItem.ToList().ForEach(f =>

                        {

                            _ServiceStartRpt.AppendLine(f.ToString());

                        });

                        //여기

                        LstService.Add(new ServiceItem { RemotingSerivce = rem, ServiceID = Guid.Parse(s.ID) });

                    }

                    catch (Exception ex)

                    {

                        StringBuilder _bl = new StringBuilder();

                        _bl.AppendLine("<Sub Service Infomation Error>");

                        _bl.AppendLine("Service ID :" + s.ID.ToString());

                        _bl.AppendLine("Service Address :" + s.SERVICE_ADDRESS);

                        _bl.AppendLine("Service Port :" + s.SERVICE_PORT);

                        _bl.AppendLine(ex.ToString());

                        SendError("Service Not Found", _bl.ToString(), 0);

                    }

                }

            });

            return _ServiceStartRpt.ToString();

        }

        public void ReAttemptConverterPDF()

        {

            using (DeepView_Entity _deepview = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

            {

                _log.Write("_deepview in");

                var _ConverterList = _deepview.CONVERTER_DOC.Where(converter

                                          => (converter.STATUS != (int)IConverterPDF.ConverterStatus.Success

                                              && converter.STATUS != (int)IConverterPDF.ConverterStatus.Error && converter.SERVICE_ID == null)

                                              || (converter.STATUS == (int)IConverterPDF.ConverterStatus.Error && converter.RECONVERTER < 4));

                _log.Write("_ConverterList count" + _ConverterList.Count());

                if (_ConverterList.Count() > 0)

                {

                    var _exceptItem = _ConverterList.Except(_WorkItems.ToList());

                    List<CONVERTER_DOC> _insertItem = _exceptItem.Except(_thread).ToList();

                    List<CONVERTER_DOC> _workingItem = new List<CONVERTER_DOC>();

                    if (LstService != null)

                    {

                        for (int i = 0; i < LstService.Count(); i++)

                        {

                            //var _guid = LstService[i].RemotingSerivce.RunningProcessID();

                            string _guid = LstService[i].RemotingSerivce.RunningProcessID().ToString();

                            var _lstconvert = from c in _deepview.CONVERTER_DOC

                                              where _guid.Contains(c.ID)

                                              select c;

                            if (_lstconvert.Count() > 0)

                                _workingItem.AddRange(_lstconvert.ToList());

                        }

                    }

                    _workingItem.ForEach(f =>

                    {

                        var _items = _insertItem.Where(item => item.PROJECT_NO == f.PROJECT_NO &&

                                                               item.DOCUMENT_ID == f.DOCUMENT_ID);

                        if (_items.Count() > 0)

                        {

                            CONVERTER_DOC _SubWorkingitem = _items.First();

                            _insertItem.Remove(_SubWorkingitem);

                        }

                    });

                    StartConverterPDFProcess(_insertItem);

                }

            }

        }

        private void StartConverterPDFProcess(List<CONVERTER_DOC> lstConverterPDF)

        {

            if (lstConverterPDF.Count() > 0)

            {

                foreach (var item in lstConverterPDF)

                {

                    System.Diagnostics.Debug.WriteLine("ConverterPDF Item 추가" + item.ID);

                    _WorkItems.Enqueue(item);

                }

                if (_ConverterPdfThread == null)

                {

                    _ConverterPdfThread = new Thread(new ThreadStart(ConverterPDFProcess));

                    _ConverterPdfThread.SetApartmentState(ApartmentState.MTA);

                    _ConverterPdfThread.Start();

                }

            }

        }

        private void ConverterPDFProcess()

        {

            while (_WorkItems.Count() > 0)

            {

                if (_thread.Count() < _MultiProcessCount)

                {

                    CONVERTER_DOC _item = _WorkItems.Dequeue();

                    var _identPathItem = _thread.Where(item => item.DOCUMENT_URL == _item.DOCUMENT_URL);

                    if (_identPathItem.Count() > 0)

                    {

                        _WorkItems.Enqueue(_item);

                    }

                    else

                    {

                        DZConverter dz = new DZConverter();

                        dz.ConverterMakeError += new EventHandler<MakeConverterErrorArgs>(dz_ConverterMakeError);

                        dz.EndConverter += new EventHandler<EndConverterEventArgs>(dz_EndConverter);

                        Thread _stathread = new Thread(new ParameterizedThreadStart(dz.GetSingleFile));

                        _stathread.Name = _item.ID.ToString();

                        _stathread.SetApartmentState(ApartmentState.MTA); //multithreaded apartment(MTA)

                        _stathread.Start(_item); //Parameter 전달

                        _thread.Add(_item);

                        SetConveterState(Guid.Parse(_item.ID), IConverterPDF.ConverterStatus.Wait);

                        System.Diagnostics.Debug.WriteLine("Status Change : " + _item.ID);

                    }

                }

                else

                {

                    if (this.SeriviceType == ConverterServiceType.Main)

                    {

                        bool _subpass = false;

                        CONVERTER_DOC _item = _WorkItems.Dequeue();

                        try

                        {

                            for (int i = 0; i < LstService.Count; i++)

                            {

                                int maxCount = LstService[i].RemotingSerivce.MultiProcessCount;

                                Guid[] _id = LstService[i].RemotingSerivce.RunningProcessID();

                                if (maxCount > _id.Count())

                                {

                                    var _conveter = LstService[i].RemotingSerivce.SetConverterPDF(_item.PROJECT_NO, Guid.Parse(_item.ID));

                                    if (_conveter.Exception == null)

                                    {

                                        _subpass = true;

                                        break;

                                    }

                                }

                            }

                        }

                        catch (Exception ex)

                        {

                            //SendError("subPass Error :" + ex.ToString());

                        }

                        if (!_subpass) _WorkItems.Enqueue(_item);

                    }

                }

                Thread.Sleep(10);

            }

            _ConverterPdfThread = null;

        }

        private void SetConveterState(Guid ConverterID, IConverterPDF.ConverterStatus Status)

        {

            using (DeepView_Entity _deepview = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

            {

                _serviceID = ConverterID.ToString();

                var converterList = _deepview.CONVERTER_DOC.Where(Converter => Converter.ID == _serviceID);

                if (converterList.Count() > 0)

                {

                    converterList.First().STATUS = (int)Status;

                    if (Status == ConverterStatus.Create)

                    {

                        converterList.First().START_DATETIME = DateTime.Now;

                    }

                    else if (Status == ConverterStatus.Success)

                    {

                        converterList.First().END_DATETIME = DateTime.Now;

                    }

                    converterList.First().SERVICE_ID = ServiceID.ToString();

                    _deepview.SaveChanges();

                }

            }

        }

        private void SetError(Guid ConverterID, string Msg, string Ex, int level)

        {

            try

            {

                using (DeepView_Entity _deepview = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

                {

                    _serviceID = ConverterID.ToString();

                    var ConverterList = _deepview.CONVERTER_DOC.Where(converter => converter.ID == _serviceID);

                    if (ConverterList.Count() > 0)

                    {

                        ConverterList.First().STATUS = (int)IConverterPDF.ConverterStatus.Error;

                        ConverterList.First().EXCEPTION = Msg;

                        _deepview.SaveChanges();

                    }

                }

            }

            catch (Exception ex)

            {

                _log.Write("database insert error" + "100");

            }

            try

            {

                StringBuilder _bl = new StringBuilder();

                _bl.AppendLine("ConverterPDFID : " + ConverterID.ToString());

                _bl.AppendLine(Msg);

                //SendError(_bl.ToString(), Ex, level);

            }

            catch (Exception ex)

            {

                _log.Write("SendMail Error" + "1023");

            }

        }

        void SendError(string Msg, string ex, int Level)

        {

            List<EmailModel> toEmailModels = new List<EmailModel>();

            EmailModel fromEmailModel = null;

            List<string> _lstID = new List<string>();

            if (!string.IsNullOrWhiteSpace(Properties.Settings.Default.ErrorNoticeID))

            {

                using (DeepView_Entity de = new DeepView_Entity(ConnectStringBuilder.DeepViewConnectionString().ToString()))

                {

                    //var errorUserList = de.ToEmail.Where(f => f.ServiceID.Value == ServiceID).ToList();

                    ////수신자

                    //errorUserList.ForEach(emailItem =>

                    //{

                    //    toEmailModels.Add(new EmailModel()

                    //                    {

                    //                        Host = emailItem.Host,

                    //                        UserID = emailItem.UserID,

                    //                        ServiceId = emailItem.ServiceID.Value

                    //                    });

                    //});

                    ////발신자

                    //var emailModel = de.FromEmail.Where(fo => fo.ServiceID == ServiceID);

                    //if (emailModel.Count() > 0)

                    //{

                    //    var emailItem = emailModel.First();

                    //    fromEmailModel = new EmailModel()

                    //                    {

                    //                        Host = emailItem.Host,

                    //                        UserID = emailItem.UserID,

                    //                        Smtp = emailItem.Smtp,

                    //                        ServiceId = emailItem.ServiceID.Value,

                    //                        SmtpPort = emailItem.SmtpPort.Value

                    //                    };

                    //}

                }

                //if (fromEmailModel != null && toEmailModels.Count > 0)

                //{

                //    string header = "<Converter Service Error Notice>";

                //    EmailClient.EmailClient _client =

                //            new EmailClient.EmailClient(fromEmailModel.UserID, fromEmailModel.Host);

                //    _client.Smtp = fromEmailModel.Smtp;

                //    _client.SmtpPort = fromEmailModel.SmtpPort;

                //    _client.IsSSL = true;

                //    _client.Send(toEmailModels, header, Msg, false);

                //}

            }

        }

        #endregion

        #region extern method

        [SuppressMessage("Microsoft.Security", "CA2118:ReviewSuppressUnmanagedCodeSecurityUsage"), SuppressUnmanagedCodeSecurity]

        [DllImport("Kernel32", SetLastError = true, CharSet = CharSet.Auto)]

        [return: MarshalAs(UnmanagedType.Bool)]

        private static extern bool GetDiskFreeSpaceEx

        (

            string lpszPath,                    // Must name a folder, must end with '\'.

            ref long lpFreeBytesAvailable,

            ref long lpTotalNumberOfBytes,

            ref long lpTotalNumberOfFreeBytes

        );

        #endregion

        //public void Init2()

        //{

        //    try

        //    {

        //        StringBuilder _ServiceStartRpt = new StringBuilder();

        //        _ServiceStartRpt.AppendLine("<Service Infomation>");

        //        int _RemotingPort = Properties.Settings.Default.RemotingPort;

        //        channel = new TcpChannel(_RemotingPort);

        //        ChannelServices.RegisterChannel(channel, false);

        //        RemotingConfiguration.RegisterWellKnownServiceType(typeof(RemConverterPDFObject),

        //                                                            "remConverterPDF", WellKnownObjectMode.Singleton);

        //        IConverterPDF.Cache.Attach(this);

        //        CheckWaitItem();

        //    }

        //    catch (Exception ex)

        //    {

        //        if (_log != null)

        //            _log.Write("RemConverterStation  : " + ex.ToString());

        //    }

        //}

    }

}