美的
查看 | 历史 | 提交 | 提交对比
admin
2024-01-10 7f291910791bdb9a545dc12ef36c3c359cfa4e59
提交 | 用户 | 时间
71e81e 1 package cn.stylefeng.guns.plcserver;
懒 2
3
4 import cn.stylefeng.guns.modular.bs.collectionParamConf.service.CollectionParamConfService;
5 import cn.stylefeng.guns.modular.bs.equipmentInfo.service.EquipmentInfoService;
6 import cn.stylefeng.guns.modular.bs.locationInfo.service.LocationInfoService;
7 import cn.stylefeng.guns.modular.cm.paramCollection.service.ParamCollectionService;
8 import cn.stylefeng.guns.modular.cm.passingStationCollection.service.PassingStationCollectionService;
9 import cn.stylefeng.guns.modular.dq.materialTraceability.service.MaterialTraceabilityService;
10 import cn.stylefeng.guns.modular.em.equipmentAlarm.service.EquipmentAlarmService;
11 import cn.stylefeng.guns.modular.em.equipmentStatus.service.EquipmentStatusService;
c64c9f 12 import cn.stylefeng.guns.modular.gm.greaseManage.service.GreaseManageService;
71e81e 13 import cn.stylefeng.guns.modular.om.productionOrdeInfo.model.params.ProductionOrdeInfoParam;
懒 14 import cn.stylefeng.guns.modular.om.productionOrdeInfo.model.result.ProductionOrdeInfoResult;
15 import cn.stylefeng.guns.modular.om.productionOrdeInfo.service.ProductionOrdeInfoService;
16 import cn.stylefeng.guns.modular.sc.repairManageInfo.service.RepairManageInfoService;
17 import cn.stylefeng.guns.modular.sc.serialNumbersConf.service.SerialNumbersConfService;
18 import cn.stylefeng.guns.plcserver.opc.GlobalVariable;
19 import cn.stylefeng.guns.plcserver.opc.OPCComm;
20 import cn.stylefeng.guns.plcserver.server.BOP010.BOP010ServerInterface;
21 import cn.stylefeng.guns.plcserver.server.BOP010.impl.BOP010ServerInterfaceImpl;
22 import cn.stylefeng.guns.plcserver.server.BOP020.BOP020ServerInterface;
23 import cn.stylefeng.guns.plcserver.server.BOP020.impl.BOP020ServerInterfaceImpl;
24 import cn.stylefeng.guns.plcserver.server.BOP030.BOP030ServerInterface;
25 import cn.stylefeng.guns.plcserver.server.BOP030.impl.BOP030ServerInterfaceImpl;
26 import cn.stylefeng.guns.plcserver.server.BOP030B.BOP030BServerInterface;
27 import cn.stylefeng.guns.plcserver.server.BOP030B.impl.BOP030BServerInterfaceImpl;
28 import cn.stylefeng.guns.plcserver.server.BOP040.BOP040ServerInterface;
29 import cn.stylefeng.guns.plcserver.server.BOP040.impl.BOP040ServerInterfaceImpl;
30 import cn.stylefeng.guns.plcserver.server.BOP040B.BOP040BServerInterface;
31 import cn.stylefeng.guns.plcserver.server.BOP040B.impl.BOP040BServerInterfaceImpl;
32 import cn.stylefeng.guns.plcserver.server.COP010.COP010ServerInterface;
33 import cn.stylefeng.guns.plcserver.server.COP010.impl.COP010ServerInterfaceImpl;
34 import cn.stylefeng.guns.plcserver.server.COP020.COP020ServerInterface;
35 import cn.stylefeng.guns.plcserver.server.COP020.impl.COP020ServerInterfaceImpl;
36 import cn.stylefeng.guns.plcserver.server.COP030.COP030ServerInterface;
37 import cn.stylefeng.guns.plcserver.server.COP030.impl.COP030ServerInterfaceImpl;
38 import cn.stylefeng.guns.plcserver.server.DOP010.DOP010ServerInterface;
39 import cn.stylefeng.guns.plcserver.server.DOP010.impl.DOP010ServerInterfaceImpl;
40 import cn.stylefeng.guns.plcserver.server.DOP020.DOP020ServerInterface;
41 import cn.stylefeng.guns.plcserver.server.DOP020.impl.DOP020ServerInterfaceImpl;
42 import cn.stylefeng.guns.plcserver.server.EOP010.EOP010ServerInterface;
43 import cn.stylefeng.guns.plcserver.server.EOP010.impl.EOP010ServerInterfaceImpl;
44 import cn.stylefeng.guns.plcserver.server.EOP020.EOP020ServerInterface;
45 import cn.stylefeng.guns.plcserver.server.EOP020.impl.EOP020ServerInterfaceImpl;
46 import cn.stylefeng.guns.plcserver.server.EOP030.EOP030ServerInterface;
47 import cn.stylefeng.guns.plcserver.server.EOP030.impl.EOP030ServerInterfaceImpl;
48 import cn.stylefeng.guns.plcserver.server.EOP040.EOP040ServerInterface;
49 import cn.stylefeng.guns.plcserver.server.EOP040.impl.EOP040ServerInterfaceImpl;
50 import cn.stylefeng.guns.plcserver.server.EOP050.EOP050ServerInterface;
51 import cn.stylefeng.guns.plcserver.server.EOP050.impl.EOP050ServerInterfaceImpl;
52 import cn.stylefeng.guns.plcserver.server.EOP060.EOP060ServerInterface;
53 import cn.stylefeng.guns.plcserver.server.EOP060.impl.EOP060ServerInterfaceImpl;
54 import cn.stylefeng.guns.plcserver.server.EOP070.EOP070ServerInterface;
55 import cn.stylefeng.guns.plcserver.server.EOP070.impl.EOP070ServerInterfaceImpl;
56 import cn.stylefeng.guns.plcserver.server.EOP070B.EOP070BServerInterface;
57 import cn.stylefeng.guns.plcserver.server.EOP070B.impl.EOP070BServerInterfaceImpl;
58 import cn.stylefeng.guns.plcserver.server.EOP080.EOP080ServerInterface;
59 import cn.stylefeng.guns.plcserver.server.EOP080.impl.EOP080ServerInterfaceImpl;
60 import cn.stylefeng.guns.plcserver.server.EOP090.EOP090ServerInterface;
61 import cn.stylefeng.guns.plcserver.server.EOP090.impl.EOP090ServerInterfaceImpl;
62 import cn.stylefeng.guns.plcserver.server.EOP090B.EOP090BServerInterface;
63 import cn.stylefeng.guns.plcserver.server.EOP090B.impl.EOP090BServerInterfaceImpl;
64 import cn.stylefeng.guns.plcserver.server.OP010.OP010ServerInterface;
65 import cn.stylefeng.guns.plcserver.server.OP010.impl.OP010ServerInterfaceImpl;
66 import cn.stylefeng.guns.plcserver.server.OP020.OP020ServerInterface;
67 import cn.stylefeng.guns.plcserver.server.OP020.impl.OP020ServerInterfaceImpl;
68 import cn.stylefeng.guns.plcserver.server.OP030.OP030ServerInterface;
69 import cn.stylefeng.guns.plcserver.server.OP030.impl.OP030ServerInterfaceImpl;
70 import cn.stylefeng.guns.plcserver.server.OP040.OP040ServerInterface;
71 import cn.stylefeng.guns.plcserver.server.OP040.impl.OP040ServerInterfaceImpl;
72 import cn.stylefeng.guns.plcserver.server.OP050.OP050ServerInterface;
73 import cn.stylefeng.guns.plcserver.server.OP050.impl.OP050ServerInterfaceImpl;
74 import cn.stylefeng.guns.plcserver.server.OP070.OP070ServerInterface;
75 import cn.stylefeng.guns.plcserver.server.OP070.impl.OP070ServerInterfaceImpl;
76 import cn.stylefeng.guns.plcserver.server.OP080.OP080ServerInterface;
77 import cn.stylefeng.guns.plcserver.server.OP080.impl.OP080ServerInterfaceImpl;
78 import cn.stylefeng.guns.plcserver.server.OP090.OP090ServerInterface;
79 import cn.stylefeng.guns.plcserver.server.OP090.impl.OP090ServerInterfaceImpl;
80 import cn.stylefeng.guns.plcserver.server.OP100.OP100ServerInterface;
81 import cn.stylefeng.guns.plcserver.server.OP100.impl.OP100ServerInterfaceImpl;
82 import cn.stylefeng.guns.plcserver.server.OP110.OP110ServerInterface;
83 import cn.stylefeng.guns.plcserver.server.OP110.impl.OP110ServerInterfaceImpl;
84 import cn.stylefeng.guns.plcserver.server.OP120.OP120ServerInterface;
85 import cn.stylefeng.guns.plcserver.server.OP120.impl.OP120ServerInterfaceImpl;
86 import cn.stylefeng.guns.plcserver.server.OP120B.OP120BServerInterface;
87 import cn.stylefeng.guns.plcserver.server.OP120B.impl.OP120BServerInterfaceImpl;
88 import cn.stylefeng.guns.plcserver.server.OP130.OP130ServerInterface;
89 import cn.stylefeng.guns.plcserver.server.OP130.impl.OP130ServerInterfaceImpl;
90 import cn.stylefeng.guns.plcserver.server.OP130B.OP130BServerInterface;
91 import cn.stylefeng.guns.plcserver.server.OP130B.impl.OP130BServerInterfaceImpl;
92 import cn.stylefeng.guns.plcserver.server.OP140.OP140ServerInterface;
93 import cn.stylefeng.guns.plcserver.server.OP140.impl.OP140ServerInterfaceImpl;
94 import cn.stylefeng.guns.plcserver.server.OP150.OP150ServerInterface;
95 import cn.stylefeng.guns.plcserver.server.OP150.impl.OP150ServerInterfaceImpl;
96 import cn.stylefeng.guns.plcserver.server.OP160.OP160ServerInterface;
97 import cn.stylefeng.guns.plcserver.server.OP160.impl.OP160ServerInterfaceImpl;
98 import cn.stylefeng.guns.plcserver.server.OP170.OP170ServerInterface;
99 import cn.stylefeng.guns.plcserver.server.OP170.impl.OP170ServerInterfaceImpl;
100 import cn.stylefeng.guns.plcserver.server.state.StateServerInterface;
101 import cn.stylefeng.guns.plcserver.server.state.impl.StateServerInterfaceImpl;
102 import org.springframework.beans.factory.annotation.Autowired;
103 import org.springframework.boot.CommandLineRunner;
104 import org.springframework.core.annotation.Order;
105 import org.springframework.stereotype.Component;
106
107 import java.util.HashMap;
108 import java.util.List;
109 import java.util.Map;
110 import java.util.concurrent.ExecutorService;
111 import java.util.concurrent.Executors;
112
113 @Component
114 @Order(1)
115 public class OpcServiceMain  implements CommandLineRunner {
116     private OPCComm opc = OPCComm.getInstance();
117
118     @Autowired
119     public ProductionOrdeInfoService productionOrdeInfoService;
120     @Autowired
121     public PassingStationCollectionService passingStationCollectionService;
122     @Autowired
123     public ParamCollectionService paramCollectionService;
124     @Autowired
125     public CollectionParamConfService collectionParamConfService;
126     @Autowired
127     public SerialNumbersConfService serialNumbersConfService;
128     @Autowired
129     private EquipmentStatusService equipmentStatusService;
130
131     @Autowired
132     private EquipmentAlarmService equipmentAlarmService;
133     @Autowired
134     private MaterialTraceabilityService materialTraceabilityService;
135     @Autowired
136     private EquipmentInfoService equipmentInfoService;
137     @Autowired
138     private RepairManageInfoService repairManageInfoService;
139
140     @Autowired
141     private LocationInfoService locationInfoService;
142
c64c9f 143     @Autowired
C 144     private GreaseManageService greaseManageService;
145
71e81e 146     @Override
懒 147     public void run(String... args) throws Exception {
148         if(GlobalVariable.TERMINATED) {
149             opc.init(productionOrdeInfoService,passingStationCollectionService,paramCollectionService,collectionParamConfService,serialNumbersConfService,
150                     equipmentStatusService,equipmentAlarmService,materialTraceabilityService,equipmentInfoService,
c64c9f 151                     repairManageInfoService,locationInfoService,greaseManageService);
71e81e 152
懒 153             GlobalVariable.PRODUCT_TYPE_MAP.put("191.220001-01","1");
154             GlobalVariable.PRODUCT_TYPE_MAP.put("191.220003-01","2");
155             GlobalVariable.PRODUCT_TYPE_MAP.put("191.220002-01","3");
156             GlobalVariable.PRODUCT_TYPE_MAP.put("191.220004-01","4");
157
158             GlobalVariable.PRODUCT_CODE_MAP.put("1","191.220001-01");
159             GlobalVariable.PRODUCT_CODE_MAP.put("2","191.220003-01");
160             GlobalVariable.PRODUCT_CODE_MAP.put("3","191.220002-01");
161             GlobalVariable.PRODUCT_CODE_MAP.put("4","191.220004-01");
162
163             ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
164             cachedThreadPool.execute(new OP010TaskThreadPool());
165             cachedThreadPool.execute(new OP020TaskThreadPool());
166             cachedThreadPool.execute(new OP030TaskThreadPool());
167             cachedThreadPool.execute(new OP040TaskThreadPool());
168             cachedThreadPool.execute(new OP050TaskThreadPool());
169             cachedThreadPool.execute(new OP070TaskThreadPool());
170             cachedThreadPool.execute(new OP080TaskThreadPool());
171             cachedThreadPool.execute(new OP090TaskThreadPool());
172             cachedThreadPool.execute(new OP100TaskThreadPool());
173             cachedThreadPool.execute(new OP110TaskThreadPool());
174      /*      cachedThreadPool.execute(new OP120TaskThreadPool());
175             cachedThreadPool.execute(new OP120BTaskThreadPool());*/
176             cachedThreadPool.execute(new OP130TaskThreadPool());
177             cachedThreadPool.execute(new OP130BTaskThreadPool());
178             cachedThreadPool.execute(new OP140TaskThreadPool());
22f70c 179            /* cachedThreadPool.execute(new OP150TaskThreadPool());*/
71e81e 180             cachedThreadPool.execute(new OP160TaskThreadPool());
懒 181             cachedThreadPool.execute(new OP170TaskThreadPool());
182
183             //COP
184             cachedThreadPool.execute(new COP010TaskThreadPool());
185             cachedThreadPool.execute(new COP020TaskThreadPool());
186             cachedThreadPool.execute(new COP030TaskThreadPool());
187
188             //BOP
189             cachedThreadPool.execute(new BOP010TaskThreadPool());
190             cachedThreadPool.execute(new BOP020TaskThreadPool());
191             cachedThreadPool.execute(new BOP030TaskThreadPool());
192             cachedThreadPool.execute(new BOP030BTaskThreadPool());
193             cachedThreadPool.execute(new BOP040TaskThreadPool());
194             cachedThreadPool.execute(new BOP040BTaskThreadPool());
195
196             //DOP
197             cachedThreadPool.execute(new DOP010TaskThreadPool());
22f70c 198             /*cachedThreadPool.execute(new DOP020TaskThreadPool());*/
71e81e 199
懒 200             //EOP
201             cachedThreadPool.execute(new EOP010TaskThreadPool());
202             cachedThreadPool.execute(new EOP020TaskThreadPool());
203             cachedThreadPool.execute(new EOP030TaskThreadPool());
204             cachedThreadPool.execute(new EOP040TaskThreadPool());
205             cachedThreadPool.execute(new EOP050TaskThreadPool());
206             cachedThreadPool.execute(new EOP060TaskThreadPool());
207             cachedThreadPool.execute(new EOP070TaskThreadPool());
208             //cachedThreadPool.execute(new EOP070BTaskThreadPool());
209
210             cachedThreadPool.execute(new EOP080TaskThreadPool());
211             cachedThreadPool.execute(new EOP090TaskThreadPool());
212             cachedThreadPool.execute(new EOP090BTaskThreadPool());
213
214             cachedThreadPool.execute(new StateTaskThreadPool());
215         }
216     }
217
218 }
219
220 class OP010TaskThreadPool implements Runnable {
221
222     private OP010ServerInterface server;
223
224     public void run() {
225         try {
226             while (GlobalVariable.TERMINATED) {
227                 server = new OP010ServerInterfaceImpl();
228                 server.monitor();
229                 Thread.sleep(GlobalVariable.SLEEP_TIME);
230             }
231         }catch(Exception e){
232             e.printStackTrace();
233         }
234     }
235 }
236
237 class OP020TaskThreadPool implements Runnable {
238
239     private OP020ServerInterface server;
240
241     public void run() {
242         try {
243             while (GlobalVariable.TERMINATED) {
244                 server = new OP020ServerInterfaceImpl();
245                 server.monitor();
246                 Thread.sleep(GlobalVariable.SLEEP_TIME);
247             }
248         }catch(Exception e){
249             e.printStackTrace();
250         }
251     }
252 }
253
254
255 class OP030TaskThreadPool implements Runnable {
256
257     private OP030ServerInterface server;
258
259     public void run() {
260         try {
261             while (GlobalVariable.TERMINATED) {
262                 server = new OP030ServerInterfaceImpl();
263                 server.monitor();
264                 Thread.sleep(GlobalVariable.SLEEP_TIME);
265             }
266         }catch(Exception e){
267             e.printStackTrace();
268         }
269     }
270 }
271
272 class OP040TaskThreadPool implements Runnable {
273
274     private OP040ServerInterface server;
275
276     public void run() {
277         try {
278             while (GlobalVariable.TERMINATED) {
279                 server = new OP040ServerInterfaceImpl();
280                 server.monitor();
281                 Thread.sleep(GlobalVariable.SLEEP_TIME);
282             }
283         }catch(Exception e){
284             e.printStackTrace();
285         }
286     }
287 }
288
289 class OP050TaskThreadPool implements Runnable {
290
291     private OP050ServerInterface server;
292
293     public void run() {
294         try {
295             while (GlobalVariable.TERMINATED) {
296                 server = new OP050ServerInterfaceImpl();
297                 server.monitor();
298                 Thread.sleep(GlobalVariable.SLEEP_TIME);
299             }
300         }catch(Exception e){
301             e.printStackTrace();
302         }
303     }
304 }
305
306 class OP070TaskThreadPool implements Runnable {
307
308     private OP070ServerInterface server;
309
310     public void run() {
311         try {
312             while (GlobalVariable.TERMINATED) {
313                 server = new OP070ServerInterfaceImpl();
314                 server.monitor();
315                 Thread.sleep(GlobalVariable.SLEEP_TIME);
316             }
317         }catch(Exception e){
318             e.printStackTrace();
319         }
320     }
321 }
322
323 class OP080TaskThreadPool implements Runnable {
324
325     private OP080ServerInterface server;
326
327     public void run() {
328         try {
329             while (GlobalVariable.TERMINATED) {
330                 server = new OP080ServerInterfaceImpl();
331                 server.monitor();
332                 Thread.sleep(GlobalVariable.SLEEP_TIME);
333             }
334         }catch(Exception e){
335             e.printStackTrace();
336         }
337     }
338 }
339
340 class OP090TaskThreadPool implements Runnable {
341
342     private OP090ServerInterface server;
343
344     public void run() {
345         try {
346             while (GlobalVariable.TERMINATED) {
347                 server = new OP090ServerInterfaceImpl();
348                 server.monitor();
349                 Thread.sleep(GlobalVariable.SLEEP_TIME);
350             }
351         }catch(Exception e){
352             e.printStackTrace();
353         }
354     }
355 }
356
357 class OP100TaskThreadPool implements Runnable {
358
359     private OP100ServerInterface server;
360
361     public void run() {
362         try {
363             while (GlobalVariable.TERMINATED) {
364                 server = new OP100ServerInterfaceImpl();
365                 server.monitor();
366                 Thread.sleep(GlobalVariable.SLEEP_TIME);
367             }
368         }catch(Exception e){
369             e.printStackTrace();
370         }
371     }
372 }
373
374 class OP110TaskThreadPool implements Runnable {
375
376     private OP110ServerInterface server;
377
378     public void run() {
379         try {
380             while (GlobalVariable.TERMINATED) {
381                 server = new OP110ServerInterfaceImpl();
382                 server.monitor();
383                 Thread.sleep(GlobalVariable.SLEEP_TIME);
384             }
385         }catch(Exception e){
386             e.printStackTrace();
387         }
388     }
389 }
390 class OP120TaskThreadPool implements Runnable {
391
392     private OP120ServerInterface server;
393
394     public void run() {
395         try {
396             while (GlobalVariable.TERMINATED) {
397                 server = new OP120ServerInterfaceImpl();
398                 server.monitor();
399                 Thread.sleep(GlobalVariable.SLEEP_TIME);
400             }
401         }catch(Exception e){
402             e.printStackTrace();
403         }
404     }
405 }
406 class OP120BTaskThreadPool implements Runnable {
407
408     private OP120BServerInterface server;
409
410     public void run() {
411         try {
412             while (GlobalVariable.TERMINATED) {
413                 server = new OP120BServerInterfaceImpl();
414                 server.monitor();
415                 Thread.sleep(GlobalVariable.SLEEP_TIME);
416             }
417         }catch(Exception e){
418             e.printStackTrace();
419         }
420     }
421 }
422
423 class OP130TaskThreadPool implements Runnable {
424
425     private OP130ServerInterface server;
426
427     public void run() {
428         try {
429             while (GlobalVariable.TERMINATED) {
430                 server = new OP130ServerInterfaceImpl();
431                 server.monitor();
432                 Thread.sleep(GlobalVariable.SLEEP_TIME);
433             }
434         }catch(Exception e){
435             e.printStackTrace();
436         }
437     }
438 }
439
440 class OP130BTaskThreadPool implements Runnable {
441
442     private OP130BServerInterface server;
443
444     public void run() {
445         try {
446             while (GlobalVariable.TERMINATED) {
447                 server = new OP130BServerInterfaceImpl();
448                 server.monitor();
449                 Thread.sleep(GlobalVariable.SLEEP_TIME);
450             }
451         }catch(Exception e){
452             e.printStackTrace();
453         }
454     }
455 }
456
457 class OP140TaskThreadPool implements Runnable {
458
459     private OP140ServerInterface server;
460
461     public void run() {
462         try {
463             while (GlobalVariable.TERMINATED) {
464                 server = new OP140ServerInterfaceImpl();
465                 server.monitor();
466                 Thread.sleep(GlobalVariable.SLEEP_TIME);
467             }
468         }catch(Exception e){
469             e.printStackTrace();
470         }
471     }
472 }
473
474 class OP150TaskThreadPool implements Runnable {
475
476     private OP150ServerInterface server;
477
478     public void run() {
479         try {
480             while (GlobalVariable.TERMINATED) {
481                 server = new OP150ServerInterfaceImpl();
482                 server.monitor();
483                 Thread.sleep(GlobalVariable.SLEEP_TIME);
484             }
485         }catch(Exception e){
486             e.printStackTrace();
487         }
488     }
489 }
490
491 class OP160TaskThreadPool implements Runnable {
492
493     private OP160ServerInterface server;
494
495     public void run() {
496         try {
497             while (GlobalVariable.TERMINATED) {
498                 server = new OP160ServerInterfaceImpl();
499                 server.monitor();
500                 Thread.sleep(GlobalVariable.SLEEP_TIME);
501             }
502         }catch(Exception e){
503             e.printStackTrace();
504         }
505     }
506 }
507
508 class OP170TaskThreadPool implements Runnable {
509
510     private OP170ServerInterface server;
511
512     public void run() {
513         try {
514             while (GlobalVariable.TERMINATED) {
515                 server = new OP170ServerInterfaceImpl();
516                 server.monitor();
517                 Thread.sleep(GlobalVariable.SLEEP_TIME);
518             }
519         }catch(Exception e){
520             e.printStackTrace();
521         }
522     }
523 }
524
525
526 class COP010TaskThreadPool implements Runnable {
527
528     private COP010ServerInterface server;
529
530     public void run() {
531         try {
532             while (GlobalVariable.TERMINATED) {
533                 server = new COP010ServerInterfaceImpl();
534                 server.monitor();
535                 Thread.sleep(GlobalVariable.SLEEP_TIME);
536             }
537         }catch(Exception e){
538             e.printStackTrace();
539         }
540     }
541 }class COP020TaskThreadPool implements Runnable {
542
543     private COP020ServerInterface server;
544
545     public void run() {
546         try {
547             while (GlobalVariable.TERMINATED) {
548                 server = new COP020ServerInterfaceImpl();
549                 server.monitor();
550                 Thread.sleep(GlobalVariable.SLEEP_TIME);
551             }
552         }catch(Exception e){
553             e.printStackTrace();
554         }
555     }
556 }
557
558 class COP030TaskThreadPool implements Runnable {
559
560     private COP030ServerInterface server;
561
562     public void run() {
563         try {
564             while (GlobalVariable.TERMINATED) {
565                 server = new COP030ServerInterfaceImpl();
566                 server.monitor();
567                 Thread.sleep(GlobalVariable.SLEEP_TIME);
568             }
569         }catch(Exception e){
570             e.printStackTrace();
571         }
572     }
573 }
574
575 class BOP010TaskThreadPool implements Runnable {
576
577     private BOP010ServerInterface server;
578
579     public void run() {
580         try {
581             while (GlobalVariable.TERMINATED) {
582                 server = new BOP010ServerInterfaceImpl();
583                 server.monitor();
584                 Thread.sleep(GlobalVariable.SLEEP_TIME);
585             }
586         }catch(Exception e){
587             e.printStackTrace();
588         }
589     }
590 }
591
592 class BOP020TaskThreadPool implements Runnable {
593
594     private BOP020ServerInterface server;
595
596     public void run() {
597         try {
598             while (GlobalVariable.TERMINATED) {
599                 server = new BOP020ServerInterfaceImpl();
600                 server.monitor();
601                 Thread.sleep(GlobalVariable.SLEEP_TIME);
602             }
603         }catch(Exception e){
604             e.printStackTrace();
605         }
606     }
607 }
608
609 class BOP030TaskThreadPool implements Runnable {
610
611     private BOP030ServerInterface server;
612
613     public void run() {
614         try {
615             while (GlobalVariable.TERMINATED) {
616                 server = new BOP030ServerInterfaceImpl();
617                 server.monitor();
618                 Thread.sleep(GlobalVariable.SLEEP_TIME);
619             }
620         }catch(Exception e){
621             e.printStackTrace();
622         }
623     }
624 }
625
626 class BOP030BTaskThreadPool implements Runnable {
627
628     private BOP030BServerInterface server;
629
630     public void run() {
631         try {
632             while (GlobalVariable.TERMINATED) {
633                 server = new BOP030BServerInterfaceImpl();
634                 server.monitor();
635                 Thread.sleep(GlobalVariable.SLEEP_TIME);
636             }
637         }catch(Exception e){
638             e.printStackTrace();
639         }
640     }
641 }
642
643 class BOP040TaskThreadPool implements Runnable {
644
645     private BOP040ServerInterface server;
646
647     public void run() {
648         try {
649             while (GlobalVariable.TERMINATED) {
650                 server = new BOP040ServerInterfaceImpl();
651                 server.monitor();
652                 Thread.sleep(GlobalVariable.SLEEP_TIME);
653             }
654         }catch(Exception e){
655             e.printStackTrace();
656         }
657     }
658 }
659
660 class BOP040BTaskThreadPool implements Runnable {
661
662     private BOP040BServerInterface server;
663
664     public void run() {
665         try {
666             while (GlobalVariable.TERMINATED) {
667                 server = new BOP040BServerInterfaceImpl();
668                 server.monitor();
669                 Thread.sleep(GlobalVariable.SLEEP_TIME);
670             }
671         }catch(Exception e){
672             e.printStackTrace();
673         }
674     }
675 }
676
677 //EOP
678 class EOP010TaskThreadPool implements Runnable {
679
680     private EOP010ServerInterface server;
681
682     public void run() {
683         try {
684             while (GlobalVariable.TERMINATED) {
685                 server = new EOP010ServerInterfaceImpl();
686                 server.monitor();
687                 Thread.sleep(GlobalVariable.SLEEP_TIME);
688             }
689         }catch(Exception e){
690             e.printStackTrace();
691         }
692     }
693 }
694 class EOP020TaskThreadPool implements Runnable {
695
696     private EOP020ServerInterface server;
697
698     public void run() {
699         try {
700             while (GlobalVariable.TERMINATED) {
701                 server = new EOP020ServerInterfaceImpl();
702                 server.monitor();
703                 Thread.sleep(GlobalVariable.SLEEP_TIME);
704             }
705         }catch(Exception e){
706             e.printStackTrace();
707         }
708     }
709 }
710
711 class EOP030TaskThreadPool implements Runnable {
712
713     private EOP030ServerInterface server;
714
715     public void run() {
716         try {
717             while (GlobalVariable.TERMINATED) {
718                 server = new EOP030ServerInterfaceImpl();
719                 server.monitor();
720                 Thread.sleep(GlobalVariable.SLEEP_TIME);
721             }
722         }catch(Exception e){
723             e.printStackTrace();
724         }
725     }
726 }
727 class EOP040TaskThreadPool implements Runnable {
728
729     private EOP040ServerInterface server;
730
731     public void run() {
732         try {
733             while (GlobalVariable.TERMINATED) {
734                 server = new EOP040ServerInterfaceImpl();
735                 server.monitor();
736                 Thread.sleep(GlobalVariable.SLEEP_TIME);
737             }
738         }catch(Exception e){
739             e.printStackTrace();
740         }
741     }
742 }
743 class EOP050TaskThreadPool implements Runnable {
744
745     private EOP050ServerInterface server;
746
747     public void run() {
748         try {
749             while (GlobalVariable.TERMINATED) {
750                 server = new EOP050ServerInterfaceImpl();
751                 server.monitor();
752                 Thread.sleep(GlobalVariable.SLEEP_TIME);
753             }
754         }catch(Exception e){
755             e.printStackTrace();
756         }
757     }
758 }
759
760 class EOP060TaskThreadPool implements Runnable {
761
762     private EOP060ServerInterface server;
763
764     public void run() {
765         try {
766             while (GlobalVariable.TERMINATED) {
767                 server = new EOP060ServerInterfaceImpl();
768                 server.monitor();
769                 Thread.sleep(GlobalVariable.SLEEP_TIME);
770             }
771         }catch(Exception e){
772             e.printStackTrace();
773         }
774     }
775 }
776
777 class EOP070TaskThreadPool implements Runnable {
778
779     private EOP070ServerInterface server;
780
781     public void run() {
782         try {
783             while (GlobalVariable.TERMINATED) {
784                 server = new EOP070ServerInterfaceImpl();
785                 server.monitor();
786                 Thread.sleep(GlobalVariable.SLEEP_TIME);
787             }
788         }catch(Exception e){
789             e.printStackTrace();
790         }
791     }
792 }
793
794 class EOP070BTaskThreadPool implements Runnable {
795
796     private EOP070BServerInterface server;
797
798     public void run() {
799         try {
800             while (GlobalVariable.TERMINATED) {
801                 server = new EOP070BServerInterfaceImpl();
802                 server.monitor();
803                 Thread.sleep(GlobalVariable.SLEEP_TIME);
804             }
805         }catch(Exception e){
806             e.printStackTrace();
807         }
808     }
809 }
810
811 class EOP080TaskThreadPool implements Runnable {
812
813     private EOP080ServerInterface server;
814
815     public void run() {
816         try {
817             while (GlobalVariable.TERMINATED) {
818                 server = new EOP080ServerInterfaceImpl();
819                 server.monitor();
820                 Thread.sleep(GlobalVariable.SLEEP_TIME);
821             }
822         }catch(Exception e){
823             e.printStackTrace();
824         }
825     }
826 }
827
828 class EOP090TaskThreadPool implements Runnable {
829
830     private EOP090ServerInterface server;
831
832     public void run() {
833         try {
834             while (GlobalVariable.TERMINATED) {
835                 server = new EOP090ServerInterfaceImpl();
836                 server.monitor();
837                 Thread.sleep(GlobalVariable.SLEEP_TIME);
838             }
839         }catch(Exception e){
840             e.printStackTrace();
841         }
842     }
843 }
844
845 class EOP090BTaskThreadPool implements Runnable {
846
847     private EOP090BServerInterface server;
848
849     public void run() {
850         try {
851             while (GlobalVariable.TERMINATED) {
852                 server = new EOP090BServerInterfaceImpl();
853                 server.monitor();
854                 Thread.sleep(GlobalVariable.SLEEP_TIME);
855             }
856         }catch(Exception e){
857             e.printStackTrace();
858         }
859     }
860 }
861
862 class DOP010TaskThreadPool implements Runnable {
863
864     private DOP010ServerInterface server;
865
866     public void run() {
867         try {
868             while (GlobalVariable.TERMINATED) {
869                 server = new DOP010ServerInterfaceImpl();
870                 server.monitor();
871                 Thread.sleep(GlobalVariable.SLEEP_TIME);
872             }
873         }catch(Exception e){
874             e.printStackTrace();
875         }
876     }
877 }
878
879 class DOP020TaskThreadPool implements Runnable {
880
881     private DOP020ServerInterface server;
882
883     public void run() {
884         try {
885             while (GlobalVariable.TERMINATED) {
886                 server = new DOP020ServerInterfaceImpl();
887                 server.monitor();
888                 Thread.sleep(GlobalVariable.SLEEP_TIME);
889             }
890         }catch(Exception e){
891             e.printStackTrace();
892         }
893     }
894 }
895
896 class StateTaskThreadPool implements Runnable {
897
898     private StateServerInterface server;
899
900     public void run() {
901         try {
902             while (GlobalVariable.TERMINATED) {
903                 server = new StateServerInterfaceImpl();
904                 server.monitor();
905                 Thread.sleep(30*1000);
906             }
907         }catch(Exception e){
908             e.printStackTrace();
909         }
910     }
911 }