비동기 테스트 추가

2024-12-30 19:01:12 +09:00
parent 4c6689db83
commit 0c93e76be6
23 changed files with 1180 additions and 59 deletions
@@ -0,0 +1,149 @@
+package com.eactive.testmaster.queue.controller;
+
+import com.eactive.testmaster.queue.entity.QueueHandler;
+import com.eactive.testmaster.queue.mapper.QueueHandlerMapper;
+import com.eactive.testmaster.queue.service.DynamicQueueManager;
+import com.eactive.testmaster.queue.service.QueueHandlerService;
+import com.eactive.testmaster.queue.dto.QueueHandlerDTO;
+import com.eactive.testmaster.queue.dto.QueueHandlerSearch;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.security.access.annotation.Secured;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.ModelMap;
+import org.springframework.validation.BindingResult;
+import org.springframework.validation.Validator;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.ModelAndView;
+import javax.annotation.PostConstruct;
+import java.util.List;
+
+@Controller
+@RequestMapping("/mgmt/queues")
+public class QueueHandlerMgmtController {
+
+    private static final String QUEUE_HANDLER = "queueHandler";
+    private static final String QUEUE_HANDLER_EDIT = "page/queues/queueHandlerEdit";
+    private static final String QUEUE_HANDLER_LIST_VIEW = "redirect:/mgmt/queues/list_view.do";
+
+    private final QueueHandlerService queueHandlerService;
+    private final Validator validator;
+    private final QueueHandlerMapper queueHandlerMapper;
+    private final DynamicQueueManager dynamicQueueManager;
+
+    public QueueHandlerMgmtController(QueueHandlerService queueHandlerService, Validator validator, QueueHandlerMapper queueHandlerMapper, DynamicQueueManager dynamicQueueManager) {
+        this.queueHandlerService = queueHandlerService;
+        this.validator = validator;
+        this.queueHandlerMapper = queueHandlerMapper;
+        this.dynamicQueueManager = dynamicQueueManager;
+
+    }
+
+
+    @PostConstruct
+    public void init() {
+        queueHandlerService.initAllQueues();
+    }
+
+    @GetMapping("/list_view.do")
+    @Secured("ROLE_MANAGE_QUEUE")
+    public ModelAndView listView(@ModelAttribute("queueHandlerSearch") QueueHandlerSearch queueHandlerSearch,
+        Pageable pageable) {
+        ModelAndView mav = new ModelAndView("page/queues/queueHandlerList");
+        Page<QueueHandler> page = queueHandlerService.findAll(queueHandlerSearch.buildSpecification(), pageable);
+        mav.addObject("page", page);
+        mav.addObject("pageable", pageable);
+        mav.addObject("modelSearch", queueHandlerSearch);
+        return mav;
+    }
+
+    @GetMapping("/create_view.do")
+    @Secured("ROLE_MANAGE_QUEUE")
+    public ModelAndView createView() {
+        ModelAndView mav = new ModelAndView(QUEUE_HANDLER_EDIT);
+        mav.addObject(QUEUE_HANDLER, new QueueHandlerDTO());
+        return mav;
+    }
+
+    @GetMapping("/update_view.do")
+    @Secured("ROLE_MANAGE_QUEUE")
+    public ModelAndView updateView(@RequestParam("id") String id) {
+        ModelAndView mav = new ModelAndView(QUEUE_HANDLER_EDIT);
+        QueueHandler found = queueHandlerService.findById(id);
+        mav.addObject(QUEUE_HANDLER, found); // Assuming direct usage of entity, you might want to use a DTO mapper
+        return mav;
+    }
+
+    @PostMapping("/register.do")
+    @Secured("ROLE_MANAGE_QUEUE")
+    public String register(@ModelAttribute("queueHandler") QueueHandlerDTO dto,
+        BindingResult bindingResult,
+        ModelMap model) {
+
+        if (dto == null) {
+            return "redirect:/mgmt/queues/create_view.do";
+        }
+
+        validator.validate(dto, bindingResult);
+
+        if (bindingResult.hasErrors()) {
+            model.addAttribute(QUEUE_HANDLER, dto);
+            return QUEUE_HANDLER_EDIT;
+        }
+
+        QueueHandler queueHandler = queueHandlerMapper.map(dto);
+        queueHandlerService.create(queueHandler);
+        queueHandlerService.initAllQueues();
+        return QUEUE_HANDLER_LIST_VIEW;
+    }
+
+    @PostMapping("/update.do")
+    @Secured("ROLE_MANAGE_QUEUE")
+    public String update(@RequestParam("queueName") String queueName,
+                        @ModelAttribute("queueHandler") QueueHandlerDTO dto,
+        BindingResult bindingResult,
+        ModelMap model) {
+
+        if (dto.getQueueName() == null) {
+            return QUEUE_HANDLER_LIST_VIEW;
+        }
+
+        validator.validate(dto, bindingResult);
+
+        if (bindingResult.hasErrors()) {
+            model.addAttribute(QUEUE_HANDLER, dto);
+            return QUEUE_HANDLER_EDIT;
+        }
+
+        QueueHandler queueHandler =  queueHandlerMapper.map(dto);
+        queueHandlerService.update(dto.getQueueName(), queueHandler);
+        queueHandlerService.initAllQueues();
+        return QUEUE_HANDLER_LIST_VIEW;
+    }
+
+    @PostMapping("/delete.do")
+    @Secured("ROLE_MANAGE_QUEUE")
+    public String delete(@RequestParam("checkedIdForDel") List<String> ids) {
+        for (String id : ids) {
+            queueHandlerService.deleteById(id);
+        }
+        queueHandlerService.initAllQueues();
+        return QUEUE_HANDLER_LIST_VIEW;
+    }
+
+    @PostMapping("/start.do")
+    @Secured("ROLE_MANAGE_QUEUE")
+    public String startQueue(@RequestParam("id") String id) {
+        QueueHandler queueHandler = queueHandlerService.findById(id);
+        dynamicQueueManager.startQueueListener(queueHandler);
+        return QUEUE_HANDLER_LIST_VIEW;
+    }
+
+    @PostMapping("/stop.do")
+    @Secured("ROLE_MANAGE_QUEUE")
+    public String stopQueue(@RequestParam("id") String id) {
+        QueueHandler queueHandler = queueHandlerService.findById(id);
+        dynamicQueueManager.stopQueueListener(queueHandler.getQueueName());
+        return QUEUE_HANDLER_LIST_VIEW;
+    }
+}
@@ -0,0 +1,24 @@
+package com.eactive.testmaster.queue.dto;
+
+public class QueueHandlerDTO {
+
+    private String queueName;
+
+    private String handlerScript;
+
+    public String getQueueName() {
+        return queueName;
+    }
+
+    public void setQueueName(String queueName) {
+        this.queueName = queueName;
+    }
+
+    public String getHandlerScript() {
+        return handlerScript;
+    }
+
+    public void setHandlerScript(String handlerScript) {
+        this.handlerScript = handlerScript;
+    }
+}
@@ -0,0 +1,30 @@
+package com.eactive.testmaster.queue.dto;
+
+import com.eactive.testmaster.common.search.BaseSearch;
+import com.eactive.testmaster.common.search.ColumnSearchModel;
+import com.eactive.testmaster.common.search.SearchCondition;
+import com.eactive.testmaster.common.search.SearchModel;
+import com.eactive.testmaster.queue.entity.QueueHandler;
+import java.util.ArrayList;
+import java.util.List;
+
+public class QueueHandlerSearch implements BaseSearch<QueueHandler> {
+
+    private String queueName;
+
+    @Override
+    public List<SearchModel> buildSearchCondition() {
+        List<SearchModel> models = new ArrayList<>();
+        models.add(new ColumnSearchModel("queueName", SearchCondition.LIKE, queueName));
+        return models;
+    }
+
+    public String getQueueName() {
+        return queueName;
+    }
+
+    public void setQueueName(String queueName) {
+        this.queueName = queueName;
+    }
+}
+
@@ -0,0 +1,31 @@
+package com.eactive.testmaster.queue.entity;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Lob;
+
+@Entity
+public class QueueHandler {
+
+    @Id
+    private String queueName;
+
+    @Lob
+    private String handlerScript;
+
+    public String getQueueName() {
+        return queueName;
+    }
+
+    public void setQueueName(String queueName) {
+        this.queueName = queueName;
+    }
+
+    public String getHandlerScript() {
+        return handlerScript;
+    }
+
+    public void setHandlerScript(String handlerScript) {
+        this.handlerScript = handlerScript;
+    }
+}
@@ -0,0 +1,20 @@
+package com.eactive.testmaster.queue.mapper;
+
+import com.eactive.testmaster.common.mapper.CommonMapper;
+import com.eactive.testmaster.queue.dto.QueueHandlerDTO;
+import com.eactive.testmaster.queue.entity.QueueHandler;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+import org.springframework.stereotype.Component;
+
+@Mapper(componentModel = "spring",
+    uses = {CommonMapper.class},
+    unmappedTargetPolicy = ReportingPolicy.IGNORE)
+@Component
+public abstract class QueueHandlerMapper {
+
+    public abstract QueueHandler map(QueueHandlerDTO queue);
+
+    public abstract QueueHandlerDTO map(QueueHandler queue);
+
+}
@@ -0,0 +1,9 @@
+package com.eactive.testmaster.queue.repository;
+
+import com.eactive.testmaster.queue.entity.QueueHandler;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+public interface QueueHandlerRepository  extends JpaRepository<QueueHandler, String>, JpaSpecificationExecutor<QueueHandler> {
+
+}
@@ -0,0 +1,73 @@
+package com.eactive.testmaster.queue.service;
+
+import com.eactive.testmaster.config.HazelcastJSBridge;
+import com.eactive.testmaster.queue.entity.QueueHandler;
+import com.hazelcast.core.HazelcastInstance;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class DynamicQueueManager {
+
+    private static final Logger logger = LoggerFactory.getLogger(DynamicQueueManager.class);
+
+    private final HazelcastInstance hazelcastInstance;
+    private final Map<String, QueueListenerService> queueListeners;
+    private final HazelcastJSBridge hazelcastJSBridge;
+
+    @Autowired
+    public DynamicQueueManager(HazelcastInstance hazelcastInstance, HazelcastJSBridge hazelcastJSBridge) {
+        this.hazelcastInstance = hazelcastInstance;
+        this.hazelcastJSBridge = hazelcastJSBridge;
+        this.queueListeners = new ConcurrentHashMap<>();
+    }
+
+    /**
+     * Start a listener for the specified queue
+     */
+//    public void startQueueListener(QueueHandler queueHandler) {
+//        if (!queueListeners.containsKey(queueHandler.getQueueName())) {
+//            QueueListenerService listener = new QueueListenerService(hazelcastInstance, hazelcastJSBridge);
+//            listener.setQueueHandler(queueHandler);
+//            queueListeners.put(queueHandler.getQueueName(), listener);
+//            listener.startListening();
+//            logger.info("Started listener for queue: {}", queueHandler.getQueueName());
+//        } else {
+//            logger.warn("Listener already exists for queue: {}", queueHandler.getQueueName());
+//        }
+//    }
+    public void startQueueListener(QueueHandler queueHandler) {
+        QueueListenerService existingListener = queueListeners.get(queueHandler.getQueueName());
+        if (existingListener != null) {
+            // If exists but not running, remove it so we can start fresh
+            if (!existingListener.isRunning()) {
+                queueListeners.remove(queueHandler.getQueueName());
+            } else {
+                logger.warn("Listener already exists and running for queue: {}", queueHandler.getQueueName());
+                return;
+            }
+        }
+
+        QueueListenerService listener = new QueueListenerService(hazelcastInstance, hazelcastJSBridge);
+        listener.setQueueHandler(queueHandler);
+        queueListeners.put(queueHandler.getQueueName(), listener);
+        listener.startListening();
+        logger.info("Started listener for queue: {}", queueHandler.getQueueName());
+    }
+
+    /**
+     * Stop a queue listener
+     */
+    public void stopQueueListener(String queueName) {
+        QueueListenerService listener = queueListeners.remove(queueName);
+        if (listener != null) {
+            listener.stopListening();
+            logger.info("Stopped listener for queue: {}", queueName);
+        }
+    }
+
+}
@@ -0,0 +1,51 @@
+package com.eactive.testmaster.queue.service;
+
+import com.eactive.testmaster.queue.entity.QueueHandler;
+import com.eactive.testmaster.queue.repository.QueueHandlerRepository;
+import javax.transaction.Transactional;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+@Service
+@Transactional
+public class QueueHandlerService {
+
+    @Autowired
+    private QueueHandlerRepository queueHandlerRepository;
+
+    @Autowired
+    private DynamicQueueManager dynamicQueueManager;
+
+    public void initAllQueues() {
+        queueHandlerRepository.findAll().forEach(queueHandler -> {
+            dynamicQueueManager.startQueueListener(queueHandler);
+        });
+    }
+
+
+    public Page<QueueHandler> findAll(Specification<QueueHandler> specification, Pageable pageable) {
+        return queueHandlerRepository.findAll(specification, pageable);
+    }
+
+    public QueueHandler findById(String id) {
+        return queueHandlerRepository.findById(id)
+            .orElseThrow(() -> new RuntimeException("Queue Handler not found with id: " + id));
+    }
+
+    public QueueHandler create(QueueHandler queueHandler) {
+        return queueHandlerRepository.save(queueHandler);
+    }
+
+    public QueueHandler update(String queueName, QueueHandler queueHandler) {
+        QueueHandler handler = queueHandlerRepository.findById(queueName).orElseThrow(() -> new IllegalArgumentException("Queue Handler not found with name: " + queueName));
+        handler.setHandlerScript(queueHandler.getHandlerScript());
+        return queueHandlerRepository.save(handler);
+    }
+
+    public void deleteById(String id) {
+        queueHandlerRepository.deleteById(id);
+    }
+}
@@ -0,0 +1,162 @@
+package com.eactive.testmaster.queue.service;
+
+import com.eactive.testmaster.config.HazelcastJSBridge;
+import com.eactive.testmaster.loadtest.service.Console;
+import com.eactive.testmaster.queue.entity.QueueHandler;
+import com.hazelcast.collection.IQueue;
+import com.hazelcast.core.HazelcastInstance;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.script.Bindings;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import javax.script.SimpleBindings;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class QueueListenerService {
+
+    private static final Logger logger = LoggerFactory.getLogger(QueueListenerService.class);
+
+    private IQueue<Object> taskQueue;
+    private final ExecutorService executorService;
+    private final AtomicBoolean running;
+    private final HazelcastInstance hazelcastInstance;
+    private final HazelcastJSBridge hazelcastJSBridge;
+    private QueueHandler queueHandler;
+    private final ScriptEngine scriptEngine;  // Add ScriptEngine as a field
+    private final Console console;
+
+    public void setQueueHandler(QueueHandler queueHandler) {
+        this.queueHandler = queueHandler;
+    }
+
+    @Autowired
+    public QueueListenerService(HazelcastInstance hazelcastInstance, HazelcastJSBridge hazelcastJSBridge) {
+        this.hazelcastInstance = hazelcastInstance;
+        this.hazelcastJSBridge = hazelcastJSBridge;
+
+        ScriptEngineManager manager = new ScriptEngineManager();
+        this.scriptEngine = manager.getEngineByName("nashorn");
+        this.hazelcastJSBridge.enhanceEngine(this.scriptEngine);
+        this.executorService = Executors.newSingleThreadExecutor();
+        this.running = new AtomicBoolean(false);
+        this.console = new Console();
+    }
+
+//    @PostConstruct
+//    public void startListening() {
+//        if (queueHandler != null) {
+//            taskQueue = hazelcastInstance.getQueue(queueHandler.getQueueName());
+//            executorService.submit(this::processQueueItems);
+//            logger.info("Queue listener started");
+//            this.running.set(true);
+//        }
+//    }
+
+    //    private void processQueueItems() {
+//        while (running.get()) {
+//            try {
+//                Object item = taskQueue.poll();
+//                if (item != null) {
+//                    processItem(item);
+//                }
+//            } catch (Exception e) {
+//                logger.error("Error processing queue item", e);
+//            }
+//        }
+//    }
+
+    @PostConstruct
+    public void startListening() {
+        if (queueHandler != null) {
+            // Set running flag BEFORE starting the processing
+            this.running.set(true);
+            taskQueue = hazelcastInstance.getQueue(queueHandler.getQueueName());
+            executorService.submit(this::processQueueItems);
+            logger.info("Queue listener started for queue: {}", queueHandler.getQueueName());
+        }
+    }
+
+    private void processQueueItems() {
+        while (running.get()) {
+            try {
+                // Use take() instead of poll() to block until an item is available
+                Object item = taskQueue.take();
+                processItem(item);
+            } catch (InterruptedException e) {
+                // Handle interruption (likely from shutdown)
+                logger.info("Queue listener interrupted, ending processing");
+                Thread.currentThread().interrupt();
+                break;
+            } catch (Exception e) {
+                logger.error("Error processing queue item", e);
+            }
+        }
+        logger.info("Queue listener stopped processing items");
+    }
+
+
+    private void processItem(Object message) {
+
+        String script = queueHandler.getHandlerScript();
+        if (script != null && !script.isEmpty()) {
+            Bindings scriptBindings = new SimpleBindings();
+            scriptBindings.put("console", this.console);
+            scriptBindings.put("message", message);
+
+            try {
+                scriptEngine.eval(script, scriptBindings);
+            } catch (ScriptException e) {
+                logger.error("Error executing request script", e);
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public boolean isRunning() {
+        return running.get();
+    }
+
+//    @PreDestroy
+//    public void stopListening() {
+//        logger.info("Stopping queue listener...");
+//        running.set(false);
+//        executorService.shutdown();
+//        try {
+//            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
+//                executorService.shutdownNow();
+//            }
+//        } catch (InterruptedException e) {
+//            Thread.currentThread().interrupt();
+//            executorService.shutdownNow();
+//        }
+//        logger.info("Queue listener stopped");
+//
+//    }
+
+    @PreDestroy
+    public void stopListening() {
+        logger.info("Stopping queue listener...");
+        running.set(false);
+        // Interrupt the blocking take() call
+        executorService.shutdownNow();
+        try {
+            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
+                logger.warn("Queue listener did not terminate in time");
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+        logger.info("Queue listener stopped");
+    }
+
+}