工控网涉密网联调

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
package org.springblade.mdm.machinefile.filewatch;
 
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.tool.utils.SpringUtil;
import org.springblade.mdm.basesetting.machine.entity.Machine;
import org.springblade.mdm.machinefile.entity.FileMonitorRecord;
import org.springblade.mdm.machinefile.entity.MachineFile;
import org.springblade.mdm.machinefile.service.FileMonitorRecordService;
import org.springblade.mdm.machinefile.service.MachineFileScanService;
import org.springblade.mdm.machinefile.service.MachineFileService;
import org.springblade.mdm.program.service.ProgramAnnotationService;
 
import java.io.IOException;
import java.nio.file.Path;
import java.util.Date;
 
@Slf4j
public class MachineFileChangeListener implements FileWatcherService.FileChangeListener{
    private final MachineFileService machineFileService;
    ProgramAnnotationService programAnnotationService;
    private final Machine machine;
    private final String dirType;
 
 
    public MachineFileChangeListener(MachineFileService aMachineFileService, ProgramAnnotationService annotationService, WatchInfo info) {
        this.machineFileService = aMachineFileService;
        this.machine = info.getMachine();
        this.dirType = info.getDirType();
        this.programAnnotationService = annotationService;
    }
    @Override
    public void onFileCreated(Path filePath) {
 
        try {
            log.info("文件创建{},mcode={},dieType={}",filePath,machine.getCode(),dirType);
 
            if(this.waitingForFileComplete(filePath)){
                log.info("{}传输完成Create,开始处理",filePath);
                MachineFileScanService fileScanService = SpringUtil.getBean(MachineFileScanService.class);
                MachineFile mf = fileScanService.readFileToMachineFile(filePath,this.machine,this.dirType);
                machineFileService.refreshFileData(mf);
            }else{
                //0928新增：文件传输没完成
                log.info("{}传输未完成Created,不处理",filePath);
            }
            saveMonitor(filePath,FileMonitorRecord.EVENT_CREATE);
        } catch (InterruptedException e) {
            log.error("sleep出错",e);
        } catch (IOException e) {
            log.error("机床文件监控created异常",e);
        }catch (Exception e) {
            log.error("机床回传文件处理异常create",e);
        }
    }
 
    /**
     * 等待文件传输完成（检测20次）
     * @param filePath 文件Path对象
     * @return 最终是否传输完成
     * @throws IOException 文件检测问题
     * @throws InterruptedException 线程等待可能引发的异常
     */
    boolean waitingForFileComplete(Path filePath) throws IOException, InterruptedException {
        final int maxWaitTimes = 20; //文件传输完成检测次数
        boolean isCompleted = false;
        for(int i=0;i<maxWaitTimes;i++){
            isCompleted = FileLockChecker.isFileComplete(filePath);
            if(isCompleted){
                break;
            }
        }
        return isCompleted;
    }
 
    @Override
    public void onFileModified(Path filePath) {
        //文件修改
        log.info("文件修改:{}",filePath);
        try {
            if(waitingForFileComplete(filePath)){
                log.info("文件传输完成Modify{}",filePath);
                MachineFileScanService fileScanService = SpringUtil.getBean(MachineFileScanService.class);
                MachineFile mf = fileScanService.readFileToMachineFile(filePath,this.machine,this.dirType);
                machineFileService.refreshFileData(mf);
            }else{
                log.warn("文件传输中，后续再操作{}",filePath);
            }
        } catch (IOException e) {
            log.error("回传文件操作IO错误",e);
        } catch (InterruptedException e) {
            log.error("sleep出错",e);
        } catch (Exception e) {
            log.error("机床回传文件处理异常",e);
        }
    }
 
    @Override
    public void onFileDeleted(Path filePath) {
        String path = filePath.toString();
        log.info("文件删除{}",filePath);
 
        try {
 
            String name = filePath.getFileName().toString();
 
            saveMonitor(filePath,FileMonitorRecord.EVENT_DELETE);
 
            MachineFile fileInDb = machineFileService.getExistsFile(name,this.dirType,this.machine.getCode());
            if(fileInDb != null){
                fileInDb.markFileDeleted();
                machineFileService.updateById(fileInDb);
            }else{
                log.info("数据库内不存在文件{}",filePath);
            }
        } catch (Exception e) {
            log.error("机床回传文件onDelete处理异常",e);
        }
    }
 
    void saveMonitor(Path filePath,int eventType){
        FileMonitorRecordService fileMonitorRecordService = SpringUtil.getBean(FileMonitorRecordService.class);
        FileMonitorRecord monitorRecord = new FileMonitorRecord();
        monitorRecord.setName(filePath.getFileName().toString());
        monitorRecord.setDirPath(filePath.getParent().toString());
 
        monitorRecord.setEventType(eventType);
        monitorRecord.setCreateTime(new Date());
        fileMonitorRecordService.save(monitorRecord);
    }
}