工控网涉密网联调

yangys

2025-09-29 4c7296d45efe849dc70a3b2e2240c905481a91c9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
package org.springblade.mdm.config;
 
import jakarta.annotation.PostConstruct;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springblade.mdm.basesetting.machine.service.MachineService;
import org.springblade.mdm.basesetting.machine.entity.Machine;
import org.springblade.mdm.commons.service.MachineDirTranslator;
import org.springblade.mdm.commons.service.ParamService;
import org.springblade.mdm.flow.service.TaskDispatchService;
import org.springblade.mdm.machinefile.entity.MachineFile;
import org.springblade.mdm.machinefile.filewatch.*;
import org.springblade.mdm.machinefile.service.MachineFileScanService;
import org.springblade.mdm.machinefile.service.MachineFileService;
import org.springblade.mdm.program.service.ProgramAnnotationService;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Component;
 
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
 
@Slf4j
@AllArgsConstructor
@Component
@EnableAsync
public class InitBean {
    private final DirectorLockService directorLockService;
    private final DynamicDirectoryWatcher directoryWatcher;
    private final MachineService machineService;
    private final MachineFileService machineFileService;
    private final ParamService paramService;
    private final ProgramAnnotationService annotationService;
    private final MachineFileScanService machineFileScanService;
    private final TaskDispatchService taskDispatchService;
    private final MachineDirTranslator dirTranslator;
    private final TaskPropertieBean taskPropertieBean;
    @PostConstruct
    public void init() {
        log.info("应用启动时执行初始化操作 @PostConstruct");
        String networkType = paramService.networkType();
        if(!ParamService.NETWORK_TYPE_SHEMI.equals(networkType)) {
            if(taskPropertieBean.isFileScanOnStart()) {
                machineFileScanService.scanMachineFile();
            }
 
            //工控网才启动文件监控
            log.info("工控网启动文件监控");
            initMachineDirMonitor();
        }else{
            //涉密网
            taskDispatchService.resetDrawingNos();
        }
    }
 
    /**
     * 初始化监控目录
     */
    void initMachineDirMonitor() {
        /*
        boolean locked = directorLockService.acquireLock();
        if (!locked) {
            log.info("回传接收目录已经被其他部署点位锁定，直接返回");
            return;
        }
 
         */
 
        List<Machine> machineList = machineService.getEnableMachines();;
        List<WatchInfo> monitorInfoList = new ArrayList<>();
        machineList.forEach(m -> {
            addToWatchDirList(monitorInfoList,m);
        });
 
        for (WatchInfo info : monitorInfoList) {
            try {
                Path dirPath = Paths.get(info.getPath());
                if(!dirPath.toFile().exists()) {
                    dirPath.toFile().mkdirs();
                }
                directoryWatcher.addDirectory(dirPath,getListener(info));
            } catch (Exception e) {
                log.error("添加监控目录异常",e);
            }
        }
 
    }
 
    void addToWatchDirList(List<WatchInfo> monitorDirList,Machine machine){
        String dir;
        //加入send文件夹
        if (StringUtils.isNotEmpty(machine.getProgSendDir())) {
            //dir = dirTranslator.trans(StringUtils.removeEnd(StringUtils.removeEnd(machine.getProgSendDir(), "/"), "\\"));
            dir = fixMachineDir(machine.getProgSendDir());
            WatchInfo watchInfo = new WatchInfo();
            watchInfo.setMachine(machine);
            watchInfo.setDirType(MachineFile.DIR_TYPE_SEND);
            watchInfo.setPath(dir);
            if (!monitorDirList.contains(watchInfo)) {
                monitorDirList.add(watchInfo);
            }
        }
 
        //加入rec文件夹
        if (StringUtils.isNotEmpty(machine.getProgReceiveDir())) {
            //dir = StringUtils.removeEnd(StringUtils.removeEnd(machine.getProgReceiveDir(), "/"), "\\");
            dir = fixMachineDir(machine.getProgReceiveDir());
            WatchInfo watchInfo = new WatchInfo();
            watchInfo.setMachine(machine);
            watchInfo.setDirType(MachineFile.DIR_TYPE_REC);
            watchInfo.setPath(dir);
            if (!monitorDirList.contains(watchInfo)) {
                monitorDirList.add(watchInfo);
            }
        }
 
        //加入temp文件夹
        if (StringUtils.isNotEmpty(machine.getProgTempDir())) {
            //dir = StringUtils.removeEnd(StringUtils.removeEnd(machine.getProgTempDir(), "/"), "\\");
            dir = fixMachineDir(machine.getProgTempDir());
            WatchInfo watchInfo = new WatchInfo();
            watchInfo.setMachine(machine);
            watchInfo.setDirType(MachineFile.DIR_TYPE_TEMP);
            watchInfo.setPath(dir);
            if (!monitorDirList.contains(watchInfo)) {
                monitorDirList.add(watchInfo);
            }
        }
    }
 
    /**
     * 翻译共享文件夹路径到 标准网络路径，去掉末尾路径分割不
     * @param dirpath 原始路径
     * @return 转换后的路径
     */
    String fixMachineDir(String dirpath){
        return dirTranslator.trans(StringUtils.removeEnd(StringUtils.removeEnd(dirpath, "/"), "\\"));
    }
 
    FileWatcherService.FileChangeListener getListener(WatchInfo info) {
        return new MachineFileChangeListener(machineFileService,annotationService,info);
    }
}