프로젝트

일반

사용자정보

통계
| 브랜치(Branch): | 개정판:

markus / ConvertService / ServiceBase / Markus.Service.Station / StationService / ServiceStationTask.cs @ 06f13e11

이력 | 보기 | 이력해설 | 다운로드 (13 KB)

1
using Markus.Service.Interface;
2
using Markus.Message;
3
using System;
4
using System.Collections.Generic;
5
using System.Diagnostics;
6
using System.Linq;
7
using System.Text;
8
using System.Threading;
9
using System.Threading.Tasks;
10
using System.Management;
11
using static Markus.Service.Extensions.Encrypt;
12
using Markus.Service.Extensions;
13
using Markus.Service.Helper;
14

    
15
namespace Markus.Service
16
{
17
    /// <summary>
18
    /// 컨버터 큐 처리 
19
    /// </summary>
20
    public partial class ServiceStation
21
    {
22
        /// <summary>
23
        /// 컨버터 실행중인 item
24
        /// </summary>
25
        private static List<ConvertItem> AliveConvertQueue = new List<ConvertItem>();
26

    
27
        /// <summary>
28
        /// 컨버터 프로세스 실행
29
        /// </summary>
30
        /// <param name="convertitem"></param>
31
        public bool ConvertProcessStart(ConvertItem convertitem)
32
        {
33
            bool result = false;
34
            try
35
            {
36
           
37
                Process ConvertProcess = new Process();
38

    
39
                ProcessContext processSendData = new ProcessContext
40
                {
41
                    ConvertID = convertitem.ConvertID,
42
                    ConnectionString = MarkusDBConnectionString,
43
                    ServiceStationUri = gServiceHostAddress.ToString(),
44
                    OriginFilePath = convertitem.OriginfilePath,
45
                    SaveDirectory = convertitem.ConvertPath,
46
                    TempDirectory = DownloadTempFolder,
47
                    ReleaseWorkMemory = ReleaseWorkMemory,
48
                    MultiThreadMaxPages = MultiThreadMaxPages,
49
                    MinFontSize = MinFontSize,
50
                    SendStatusInterval = SaveStatusInterval,
51
                    UseResolution = UseResolution
52
                };
53

    
54
                var sendData = ObjectToBytesStringConvert.ObjectToBytesString(processSendData);
55
                
56
                ProcessStartInfo startInfo = new ProcessStartInfo
57
                {
58
                    UseShellExecute = false,
59
                    FileName = "Markus.Service.ConvertProcess.exe",
60
                    WindowStyle = ProcessWindowStyle.Hidden,
61
                    CreateNoWindow = true,
62
                    ErrorDialog = false,
63
                    RedirectStandardError = false,
64
                    Arguments = $"{convertitem.ConvertID.ToString()} {AESEncrypter.Encrypt(sendData)}"
65
                    //Arguments = $"{convertitem.ConvertID.ToString()} {convertitem.ProjectNumber} {AESEncrypter.Encrypt(MarkusDBConnectionString)} {gServiceHostAddress} {DownloadTempFolder} {MultiThreadMaxPages}"
66
                };
67

    
68
                ConvertProcess.StartInfo = startInfo;
69
                ConvertProcess.EnableRaisingEvents = false;
70

    
71
                System.Diagnostics.Debug.WriteLine("convert process run : " + startInfo.Arguments);
72

    
73

    
74
                if (ConvertProcess.Start())
75
                {
76
                    try
77
                    {
78
                        var processAffinity = ProcessorAffinityList.Except(AliveConvertQueue.Select(f => (long)f.ProcessorAffinity));
79

    
80
                        if (processAffinity.Count() > 0)
81
                        {
82
                            convertitem.ProcessorAffinity = processAffinity.First();
83

    
84
                            //int bitMask = 1 << (convertitem.ProcessorAffinity - 1);
85
                            //bitMask |= 1 << (anotherUserSelection - 1); / //  프로세스 두개 이상 선택
86

    
87
                            ConvertProcess.ProcessorAffinity = new IntPtr(convertitem.ProcessorAffinity);
88

    
89
                        }
90
                        else
91
                        {
92
                            // 모두 사용중일때 점유율이 작은 걸로 사용
93
                            var CurrentProcessAffinity = AliveConvertQueue.Select(f =>f.ProcessorAffinity).Distinct();
94

    
95
                            var affinity = CurrentProcessAffinity.Min();
96

    
97
                            convertitem.ProcessorAffinity = affinity;
98
                            ConvertProcess.ProcessorAffinity = new IntPtr(affinity);
99
                        }
100
                    }
101
                    catch (Exception ex)
102
                    {
103
                        System.Diagnostics.Debug.WriteLine(ex);
104
                    }
105
        
106

    
107
                    ServiceStation.AliveConvertQueue.Add(convertitem);
108
                    result = true;
109
                }
110
            }
111
            catch (Exception ex)
112
            {
113
                throw new Exception("ConvertThread " + $"{convertitem.ConvertID.ToString()} {convertitem.ProjectNumber} {AESEncrypter.Encrypt(MarkusDBConnectionString)} {gServiceHostAddress} {DownloadTempFolder} {MultiThreadMaxPages}", ex.InnerException);
114
            }
115
            finally
116
            {
117
                //GC.WaitForPendingFinalizers();
118
                //GC.Collect(2);
119
                //GC.Collect(2);
120
            }
121

    
122
            return result;
123
        }
124
    
125
        /// <summary>
126
        /// DB에 있는 대기중인 Item을 가져온다.
127
        /// </summary>
128
        public void setDataBaseWaitingList()
129
        {
130
            using (DataBase.ConvertDatabase database = new DataBase.ConvertDatabase(MarkusDBConnectionString))
131
            {
132
                var convertItems = database.GetWaitConvertItems(this.RunProjectList, StationServiceList.Where(x=>x.IsOnline).Sum(f=>f.Properties.PROCESS_COUNT));
133

    
134
                foreach (var convert in convertItems)
135
                {
136
                    if (convert.STATUS > (int)StatusCodeType.None)
137
                    {
138
                        database.SetCleanUpItem(convert.ID);
139
                    }
140

    
141
                    PassConvertItem(convert.PROJECT_NO, convert.ID);
142
                }
143
            }
144
        }
145

    
146
        private void ReflashSubService()
147
        {
148
            foreach (var subservice in StationServiceList)
149
            {
150
                try
151
                {
152
                    subservice.IsOnline = SytemNet.Ping(subservice.Properties.SERVICE_ADDRESS);
153

    
154
                    if (subservice.IsOnline)
155
                    {
156
                        var result = subservice.Service.AliveConvertList();
157

    
158
                        subservice.ConvertItems = result.ToList();
159
                        subservice.AliveCount = result.Count();
160
                    }
161
                    else
162
                    {
163
                        logger.Error($"Connection Error {subservice.Properties.SERVICE_ADDRESS}");
164
                        subservice.ConvertItems = new List<WcfClient.StationServiceAsync.ConvertItem>();
165
                        subservice.AliveCount = subservice.Properties.PROCESS_COUNT;
166
                    }
167
                }
168
                catch (Exception ex)
169
                {
170
                    logger.Error($"ReflashSubService error - Service ID : {subservice.Properties.ID} ", ex);
171
                }
172
            }
173
        }
174

    
175

    
176
        private void PassConvertItem(string ProjectNo,string ConvertID)
177
        {
178

    
179
            try
180
            {
181

    
182
                var stationList = StationServiceList.Where(x => x.IsOnline);
183

    
184
                if (stationList.SelectMany(x => x.ConvertItems).Count(c => c.ProjectNumber == ProjectNo && c.ConvertID == ConvertID) == 0)
185
                {
186
                    var station = stationList.OrderByDescending(x => x.Properties.PROCESS_COUNT - x.AliveCount).FirstOrDefault();
187

    
188
                    if (station != null)
189
                    {
190
                        station.Service.ConvertAddAsync(ProjectNo, ConvertID);
191
                        logger.Info($"PassConvertItem - Service ID : {station.Properties.ID} ConvertID : {ConvertID}");
192
                    }
193
                }
194
            }
195
            catch (Exception ex)
196
            {
197
                logger.Error($"setDataBaseWaitingList", ex);
198
            }
199
        }
200

    
201
        private void CleanUpAliveQueueItems()
202
        {
203
            var processList = Process.GetProcessesByName("Markus.Service.ConvertProcess");
204

    
205
            if (processList.Length == 0)
206
            {
207
                AliveConvertQueue.Clear();
208
                System.Diagnostics.Debug.WriteLine("AliveConvertQueue.Clear()");
209
            }
210
            else
211
            {
212
                var argumentList = processList.Select(f => f.Arguments().CommandLine).SelectMany(f => f);
213

    
214
                for (int i = AliveConvertQueue.Count - 1; i >= 0; --i)
215
                {
216
                    if (argumentList.Count(x => x == AliveConvertQueue[i].ConvertID) == 0)
217
                    {
218
                        AliveConvertQueue.RemoveAt(i);
219
                    }
220
                }
221

    
222
                //foreach (var process in processList)
223
                //{
224
                //    var arguments = process.Arguments();
225

    
226
                //    if (arguments.CommandLine?.Count() == 2)
227
                //    {
228
                //        if (AliveConvertQueue.Count(x => x.ConvertID == arguments.CommandLine.First()) == 0)
229
                //        {
230
                //            var convetContext = ObjectToBytesStringConvert.BytesStringToObject<ProcessContext>(AESEncrypter.Decrypt(arguments.CommandLine[1]));
231

    
232
                //            if (convetContext.ServiceStationUri == this.gServiceHostAddress.ToString())
233
                //            {
234
                //                process.Kill();
235
                //            }
236
                //        }
237
                //    }
238
                //}
239
            }
240

    
241
        }
242

    
243
        private void CleanUpDataBaseItems()
244
        {
245
            using (DataBase.ConvertDatabase database = new DataBase.ConvertDatabase(MarkusDBConnectionString))
246
            {
247
                var items = database.GetConvertingItems(RunProjectList);
248

    
249
                List< WcfClient.StationServiceAsync.ConvertItem> aliveItems = new List<WcfClient.StationServiceAsync.ConvertItem>();
250

    
251
                foreach (var item in StationServiceList.Where(x=>x.IsOnline))
252
                {
253
                    try
254
                    {
255
                        aliveItems.AddRange(item.Service.AliveConvertList());
256
                    }
257
                    catch (Exception)
258
                    {
259
                    }
260
                }
261

    
262
                foreach (var item in items)
263
                {
264
                    if(aliveItems.Count(x=>x.ConvertID == item.ID) == 0)
265
                    {
266
                        database.SetCleanUpItem(item.ID);
267
                    }
268
                }
269
            }
270
        }
271

    
272

    
273
        public void Stopprocess()
274
        {
275
            var process = Process.GetProcessesByName("Markus.Service.ConvertProcess");
276

    
277
            for (int i = process.Count() - 1; i >= 0 ; i--)
278
            {
279
                try
280
                {
281
                    Console.WriteLine($"{i} Process Kill");
282
                    process[i].Kill();
283
                }
284
                catch (Exception ex)
285
                {
286
                    System.Diagnostics.Debug.WriteLine(ex.ToString());
287
                }
288
            }
289
        }
290

    
291
        /// <summary>
292
        /// finish가 호출되고 살아있는 프로세스라고 추정됨
293
        /// </summary>
294
        public void DeadLockProcessKill()
295
        {
296
            var process = Process.GetProcessesByName("Markus.Service.ConvertProcess");
297

    
298
            for (int i = process.Count() - 1; i >= 0; i--)
299
            {
300
                try
301
                {
302
                    var commandLines = process[i].Arguments().CommandLine;
303

    
304
                    if (commandLines.Count() > 0)
305
                    {
306
                        if (ServiceStation.AliveConvertQueue.Count(f => f.ConvertID == commandLines[0]) == 0)
307
                        {
308
                            process[i].Kill();
309
                        }
310
                    }
311
                }
312
                catch (Exception ex)
313
                {
314
                    System.Diagnostics.Debug.WriteLine(ex.ToString());
315
                }
316
            }
317
        }
318

    
319
        private void ConvertFinish(ConvertItem convertitem)
320
        {
321
            try
322
            {
323
                System.Diagnostics.Debug.WriteLine("Convert Finish : " + convertitem.ConvertID);
324

    
325
                System.Diagnostics.Debug.WriteLine("ServiceStation.AliveConvertQueue.Count() : " + ServiceStation.AliveConvertQueue.Count());
326
                
327
                ServiceStation.AliveConvertQueue.Remove(convertitem);
328

    
329
                System.Diagnostics.Debug.WriteLine("ServiceStation.AliveConvertQueue.Count() : " + ServiceStation.AliveConvertQueue.Count());
330

    
331
                if (IsStation)
332
                {
333
                    System.Diagnostics.Debug.WriteLine("setDataBaseWaitingList");
334
                    setDataBaseWaitingList();
335
                    System.Diagnostics.Debug.WriteLine("ReleaseItems end");
336
                }
337
                else
338
                {
339
                    if (StationClient != null)
340
                    {
341
                        StationClient.ReleaseConvertItems();
342
                    }
343
                }
344
                //if (ServiceStation.AliveConvertQueue.Count() < MultiProcessCount)
345
                //{
346
                //    setDataBaseWaitingList();
347
                //}
348
            }
349
            catch (Exception ex)
350
            {
351
                logger.Error("ConvertFinish Error",ex);
352
            }
353
        }
354
    }
355
}
클립보드 이미지 추가 (최대 크기: 500 MB)