Выбор сервиса в паттернах

build.gradle

@@ -27,6 +27,7 @@ dependencies {
     implementation "org.springframework.boot:spring-boot-starter-security"
     implementation "org.springframework.boot:spring-boot-starter-websocket"
     implementation 'org.springframework.session:spring-session-core'
+    compile 'com.github.jmnarloch:modelmapper-spring-boot-starter:1.1.0'
     compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.10'
     compile group: 'commons-io', name: 'commons-io', version: '2.7'
     compile 'org.pcap4j:pcap4j-core:1.8.2'

src/main/java/ru/serega6531/packmate/model/Pattern.java

@@ -42,6 +42,8 @@ public class Pattern {
 
     private PatternActionType actionType;
 
+    private Integer serviceId;
+
     private long searchStartTimestamp;
 
     @ManyToMany(mappedBy = "foundPatterns", fetch = FetchType.LAZY)

src/main/java/ru/serega6531/packmate/model/pojo/PatternDto.java

@@ -16,5 +16,6 @@ public class PatternDto {
     private PatternSearchType searchType;
     private PatternDirectionType directionType;
     private PatternActionType actionType;
+    private Integer serviceId;
 
 }

src/main/java/ru/serega6531/packmate/service/PatternService.java

@@ -6,6 +6,7 @@ import org.modelmapper.ModelMapper;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
+import ru.serega6531.packmate.model.CtfService;
 import ru.serega6531.packmate.model.FoundPattern;
 import ru.serega6531.packmate.model.Pattern;
 import ru.serega6531.packmate.model.enums.PatternActionType;
@@ -27,17 +28,19 @@ public class PatternService {
     private final PatternRepository repository;
     private final StreamService streamService;
     private final SubscriptionService subscriptionService;
+    private final ModelMapper modelMapper;
 
     private final Map<Integer, Pattern> patterns = new HashMap<>();
-    private final ModelMapper modelMapper = new ModelMapper();
 
     @Autowired
     public PatternService(PatternRepository repository,
                           @Lazy StreamService streamService,
-                          SubscriptionService subscriptionService) {
+                          SubscriptionService subscriptionService,
+                          ModelMapper modelMapper) {
         this.repository = repository;
         this.streamService = streamService;
         this.subscriptionService = subscriptionService;
+        this.modelMapper = modelMapper;
 
         repository.findAll().forEach(p -> patterns.put(p.getId(), p));
         log.info("Loaded {} patterns", patterns.size());
@@ -51,9 +54,10 @@ public class PatternService {
         return patterns.values();
     }
 
-    public Set<FoundPattern> findMatches(byte[] bytes, PatternDirectionType directionType, PatternActionType actionType) {
+    public Set<FoundPattern> findMatches(byte[] bytes, CtfService service, PatternDirectionType directionType, PatternActionType actionType) {
         final List<Pattern> list = patterns.values().stream()
                 .filter(Pattern::isEnabled)
+                .filter(p -> p.getServiceId() == null || p.getServiceId() == service.getPort())
                 .filter(p -> p.getActionType() == actionType)
                 .filter(p -> p.getDirectionType() == directionType || p.getDirectionType() == PatternDirectionType.BOTH)
                 .collect(Collectors.toList());

src/main/java/ru/serega6531/packmate/service/ServicesService.java

@@ -31,16 +31,18 @@ public class ServicesService {
     private final InetAddress localIp;
 
     private final Map<Integer, CtfService> services = new HashMap<>();
-    private final ModelMapper modelMapper = new ModelMapper();
+    private final ModelMapper modelMapper;
 
     @Autowired
     public ServicesService(ServiceRepository repository,
                            SubscriptionService subscriptionService,
                            @Lazy PcapService pcapService,
+                           ModelMapper modelMapper,
                            @Value("${local-ip}") String localIpString) throws UnknownHostException {
         this.repository = repository;
         this.subscriptionService = subscriptionService;
         this.pcapService = pcapService;
+        this.modelMapper = modelMapper;
         this.localIp = InetAddress.getByName(localIpString);
 
         repository.findAll().forEach(s -> services.put(s.getPort(), s));

src/main/java/ru/serega6531/packmate/service/StreamService.java

@@ -37,11 +37,11 @@ public class StreamService {
     private final CountingService countingService;
     private final SubscriptionService subscriptionService;
     private final RsaKeysHolder keysHolder;
+    private final ModelMapper modelMapper;
 
     private final boolean ignoreEmptyPackets;
 
     private final java.util.regex.Pattern userAgentPattern = java.util.regex.Pattern.compile("User-Agent: (.+)\\r\\n");
-    private final ModelMapper modelMapper = new ModelMapper();
 
     @Autowired
     public StreamService(StreamRepository repository,
@@ -50,6 +50,7 @@ public class StreamService {
                          CountingService countingService,
                          SubscriptionService subscriptionService,
                          RsaKeysHolder keysHolder,
+                         ModelMapper modelMapper,
                          @Value("${ignore-empty-packets}") boolean ignoreEmptyPackets) {
         this.repository = repository;
         this.patternService = patternService;
@@ -57,6 +58,7 @@ public class StreamService {
         this.countingService = countingService;
         this.subscriptionService = subscriptionService;
         this.keysHolder = keysHolder;
+        this.modelMapper = modelMapper;
         this.ignoreEmptyPackets = ignoreEmptyPackets;
     }
 
@@ -103,7 +105,7 @@ public class StreamService {
 
         packets = new StreamOptimizer(keysHolder, service, packets).optimizeStream();
 
-        if (isStreamIgnored(packets)) {
+        if (isStreamIgnored(packets, service)) {
             log.debug("New stream is ignored");
             return false;
         }
@@ -115,7 +117,7 @@ public class StreamService {
             packet.setStream(savedStream);
         }
 
-        Set<Pattern> foundPatterns = matchPatterns(packets);
+        Set<Pattern> foundPatterns = matchPatterns(packets, service);
         savedStream.setFoundPatterns(foundPatterns);
         savedStream.setPackets(packets);
         savedStream = save(savedStream);
@@ -167,12 +169,13 @@ public class StreamService {
         return "" + alphabet[hash % l] + alphabet[(hash / l) % l] + alphabet[(hash / (l * l)) % l];
     }
 
-    private Set<Pattern> matchPatterns(List<Packet> packets) {
+    private Set<Pattern> matchPatterns(List<Packet> packets, CtfService service) {
         Set<Pattern> foundPatterns = new HashSet<>();
 
         for (Packet packet : packets) {
             PatternDirectionType direction = packet.isIncoming() ? PatternDirectionType.INPUT : PatternDirectionType.OUTPUT;
-            final Set<FoundPattern> matches = patternService.findMatches(packet.getContent(), direction, PatternActionType.FIND);
+            final Set<FoundPattern> matches = patternService.findMatches(packet.getContent(), service,
+                    direction, PatternActionType.FIND);
 
             packet.setMatches(matches);
             matches.forEach(m -> m.setPacket(packet));
@@ -210,10 +213,11 @@ public class StreamService {
         return matched;
     }
 
-    private boolean isStreamIgnored(List<Packet> packets) {
+    private boolean isStreamIgnored(List<Packet> packets, CtfService service) {
         for (Packet packet : packets) {
             PatternDirectionType direction = packet.isIncoming() ? PatternDirectionType.INPUT : PatternDirectionType.OUTPUT;
-            final Set<FoundPattern> matches = patternService.findMatches(packet.getContent(), direction, PatternActionType.IGNORE);
+            final Set<FoundPattern> matches = patternService.findMatches(packet.getContent(), service,
+                    direction, PatternActionType.IGNORE);
             if (!matches.isEmpty()) {
                 return true;
             }