调整代码

pom.xml

@@ -28,6 +28,11 @@
 		</dependency>
 		<dependency>
 			<groupId>com.fdkankan</groupId>
+			<artifactId>4dkankan-utils-rubber-sheeting</artifactId>
+			<version>2.0.0-SNAPSHOT</version>
+		</dependency>
+		<dependency>
+			<groupId>com.fdkankan</groupId>
 			<artifactId>4dkankan-utils-fyun</artifactId>
 			<version>2.0.0-SNAPSHOT</version>
 		</dependency>

src/main/java/com/fdkankan/modeling/constants/SysConstants.java

@@ -1,48 +1,55 @@
 package com.fdkankan.modeling.constants;
 
-import cn.hutool.core.util.StrUtil;
 import com.fdkankan.common.util.FileUtils;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.core.env.MapPropertySource;
+import org.springframework.core.env.StandardEnvironment;
 import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
 import org.springframework.util.ObjectUtils;
 
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
 @Component
-public class SysConstants {
+public class SysConstants implements ApplicationContextAware {
     private static final Logger log = LoggerFactory.getLogger(SysConstants.class);
 
     public static String hostName;
     public static int modelTimeOut;
 
-    public static List<String> residenceServiceHostName = new ArrayList<>();
+    public static boolean isResidenceService = true;
 
     public static volatile Boolean SYSTEM_BUILDING = false;
     public static volatile Boolean SYSTEM_OFFING = false;
 
-    public static ExecutorService executorService = Executors.newFixedThreadPool(1);
+    private List<String> residenceServices = null;
 
-    public static final String DINGTALK_MSG_PATTERN = "**环境**: %s\n\n" +
-            "**服务器名称**: %s\n\n" +
-            "**失败原因**: %s\n\n" +
-            "**num**: %s\n\n" +
-            "**server-path**: %s\n\n" +
-            "**algorithm-log**: [https://4dkk.4dage.com/build_log/%s/console.log](https://4dkk.4dage.com/build_log/%s/console.log)";
+    public static final String SYSTEM_PREFIX = "model-center";
+
+    public static final String SCENE_BUILDING = SYSTEM_PREFIX+":scene:building:";
+
+    public static ExecutorService executorService = Executors.newFixedThreadPool(1);
 
     @Value("${hostName.filePath:/opt/hosts/hosts.txt}")
     public void setHostName(String filePath){
         try {
             SysConstants.hostName = FileUtils.readFile(filePath);
-            //去除换行符
-            if(StrUtil.isNotEmpty(SysConstants.hostName)){
+            // 去除空格
+            if(!ObjectUtils.isEmpty(SysConstants.hostName)){
                 SysConstants.hostName = SysConstants.hostName.trim().replaceAll("\\s","");
             }
-            log.info("从文件({})中获取服务器名称:{}", filePath,hostName);
+            log.error("从文件({})中获取服务器名称:{}", filePath,hostName);
+            initIsResidenceService();
         } catch (Exception e) {
             log.error("从文件中获取服务器名称失败,文件路径{}", filePath);
             e.printStackTrace();
@@ -53,7 +60,7 @@ public class SysConstants {
      * 默认超时时间2天
      * @param timeOut
      */
-    @Value("${model.timeOut:48}")
+    @Value("${model.timeOut:172800}")
     public void setModelTimeOut(int timeOut){
         SysConstants.modelTimeOut = timeOut;
     }
@@ -63,8 +70,33 @@ public class SysConstants {
      */
     @Value("${residenceService.hostNames:#{null}}")
     public void setResidenceServiceHostName(String[] hostNames){
-        if(!ObjectUtils.isEmpty(hostNames)){
-            SysConstants.residenceServiceHostName = Arrays.asList(hostNames);
+        if (!ObjectUtils.isEmpty(hostNames)) {
+            residenceServices = Arrays.asList(hostNames);
+            initIsResidenceService();
+        }
+    }
+
+    private void initIsResidenceService() {
+        if(CollectionUtils.isEmpty(residenceServices) || ObjectUtils.isEmpty(SysConstants.hostName)){
+            log.error("判断常驻服务失败！");
+            return;
+        }
+        log.info("常驻服务列表：{}", residenceServices);
+        log.info("当前服务名称：{}", SysConstants.hostName);
+        isResidenceService = residenceServices.contains(hostName);
+        log.info("当前服务是否是常驻服务：{}", isResidenceService);
+    }
+
+    @Override
+    public void setApplicationContext(ApplicationContext context) throws BeansException {
+        Map<String,Object> params = new HashMap<>();
+        if (isResidenceService) {
+            params.put("mq.consumerPriority",1);
+
+        } else {
+            params.put("mq.consumerPriority",0);
         }
+        ((StandardEnvironment)context.getEnvironment()).getPropertySources()
+                .addLast(new MapPropertySource("mq.consumerPriority",params));
     }
 }

src/main/java/com/fdkankan/modeling/entity/BuildLog.java

@@ -50,12 +50,7 @@ public class BuildLog implements Serializable {
     private String queueName;
 
     /**
-     * -10:其他原因失败
--3:重复计算
--2:计算失败
--1:计算超时
-0:计算中
-1:计算成功
+     * ModelingBuildStatus
      */
     @TableField("build_status")
     private Integer buildStatus;
@@ -66,6 +61,12 @@ public class BuildLog implements Serializable {
     @TableField("host_name")
     private String hostName;
 
+    /**
+     * 计算类型
+     * 0:场景计算
+     * 1:标定算法，
+     * 2:只生激光场景OBJ文件
+     */
     @TableField("build_type")
     private Integer buildType;
 

src/main/java/com/fdkankan/modeling/job/EcsJob.java

@@ -1,16 +1,18 @@
 package com.fdkankan.modeling.job;
 
-import com.fdkankan.common.util.RubberSheetingUtil;
 import com.fdkankan.modeling.constants.SysConstants;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-import javax.annotation.PostConstruct;
+import com.fdkankan.rubbersheeting.RubberSheetingUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.util.ObjectUtils;
 
+import javax.annotation.PostConstruct;
+import java.util.Random;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
 @Component
 public class EcsJob {
 
@@ -21,17 +23,15 @@ public class EcsJob {
 
     @PostConstruct
     public void deleteEcs() {
-        log.info("常驻服务列表：{}", SysConstants.residenceServiceHostName);
-        log.info("当前服务名称：{}", SysConstants.hostName);
-        log.info("当前服务是否是常驻服务：{}", SysConstants.residenceServiceHostName.contains(SysConstants.hostName));
-        if (!ObjectUtils.isEmpty(SysConstants.residenceServiceHostName) && SysConstants.residenceServiceHostName.contains(SysConstants.hostName)) {
-            log.info("此服务是常驻服务");
+        if (SysConstants.isResidenceService) {
+            log.info("此服务是常驻服务,不启动关闭弹性伸缩定时任务！");
             return;
         }
+        log.info("此服务非常驻服务,开始启动关闭弹性伸缩定时任务");
         Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(() -> {
-
                     // 判断是否有任务执行
                     if (SysConstants.SYSTEM_BUILDING) {
+                        log.error("{} 服务构建中，退出停止服务请求！", SysConstants.hostName);
                         return;
                     }
                     log.info("服务未构建，准备停止服务！");
@@ -45,10 +45,31 @@ public class EcsJob {
                             log.error("{} 服务构建中，退出停止服务请求！", SysConstants.hostName);
                         }
                     }
+                    // 因为 阿里云同一时间不能删除多台实例，因此做随机睡眠，错开时间。
+                    try {
+                        Thread.sleep((new Random().nextInt(30) + 10) * 1000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
                     // 没有任务执行时，则退出
                     if (SysConstants.executorService.isShutdown() && SysConstants.executorService.isTerminated()) {
                         log.error("{} 请求阿里云关闭弹性伸缩", SysConstants.hostName);
-                        rubberSheetingUtil.deleteEcs(SysConstants.hostName);
+                        String result = null;
+                        int tryTimes = -1;
+                        do {
+                            tryTimes++;
+                            result = rubberSheetingUtil.deleteEcs(SysConstants.hostName);
+                            if (ObjectUtils.isEmpty(result)) {
+                                int time = new Random().nextInt(10) + 30;
+                                log.error("{} 关闭弹性伸缩失败,{}秒后重试", SysConstants.hostName, time);
+                                try {
+                                    Thread.sleep(time * 1000);
+                                } catch (InterruptedException e) {
+                                    e.printStackTrace();
+                                }
+                            }
+                        } while (ObjectUtils.isEmpty(result) && tryTimes < 5);
+                        log.error("{} 关闭弹性伸缩成功！", SysConstants.hostName);
                     } else {
                         log.error("{} 服务构建中，退出删除程序失败！", SysConstants.hostName);
                     }

src/main/java/com/fdkankan/modeling/receiver/RabbitMqListener.java

@@ -5,14 +5,11 @@ import cn.hutool.core.util.StrUtil;
 import com.alibaba.fastjson.JSONObject;
 import com.fdkankan.common.constant.ConstantFilePath;
 import com.fdkankan.common.constant.ModelingBuildStatus;
-import com.fdkankan.common.constant.ServerCode;
 import com.fdkankan.common.constant.UploadFilePath;
-import com.fdkankan.common.exception.BusinessException;
 import com.fdkankan.common.util.ComputerUtil;
 import com.fdkankan.common.util.CreateObjUtil;
 import com.fdkankan.common.util.FileUtils;
 import com.fdkankan.common.util.SceneUtil;
-import com.fdkankan.dingtalk.DingTalkSendUtils;
 import com.fdkankan.fyun.oss.UploadToOssUtil;
 import com.fdkankan.modeling.bean.BuildSceneResultBean;
 import com.fdkankan.modeling.constants.SysConstants;
@@ -26,26 +23,28 @@ import com.fdkankan.rabbitmq.util.RabbitMqProducer;
 import com.fdkankan.redis.constant.RedisKey;
 import com.fdkankan.redis.util.RedisUtil;
 import com.rabbitmq.client.Channel;
-import java.io.File;
-import java.nio.charset.StandardCharsets;
-import java.util.Calendar;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.time.StopWatch;
 import org.springframework.amqp.core.Message;
 import org.springframework.amqp.rabbit.annotation.Queue;
 import org.springframework.amqp.rabbit.annotation.RabbitListener;
+import org.springframework.amqp.support.AmqpHeaders;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.messaging.handler.annotation.Header;
 import org.springframework.stereotype.Component;
 import org.springframework.util.ObjectUtils;
 import org.springframework.web.client.RestTemplate;
 
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
 /**
  * <p>
  * TODO
@@ -66,16 +65,13 @@ public class RabbitMqListener {
     private String queueModelingPost;
 
     @Autowired
-    RedisUtil redisUtil;
+    private RedisUtil redisUtil;
 
     private RestTemplate restTemplate = new RestTemplate();
 
     @Value("${4dkk.laserService.host}")
     private String laserHost;
 
-    @Value("${upload.type}")
-    private String ossType;
-
     @Value("${oss.prefix.ali}")
     private String prefixAli;
 
@@ -83,13 +79,7 @@ public class RabbitMqListener {
     private UploadToOssUtil uploadToOssUtil;
 
     @Autowired
-    RabbitMqProducer rabbitMqProducer;
-
-    @Value("${spring.profiles.active}")
-    private String environment;
-
-    @Autowired
-    private DingTalkSendUtils dingTalkSendUtils;
+    private RabbitMqProducer rabbitMqProducer;
 
     @Autowired
     private IBuildLogService buildLogService;
@@ -102,47 +92,49 @@ public class RabbitMqListener {
      */
     @RabbitListener(
         queuesToDeclare = @Queue("${queue.modeling.modeling-call}"),
-        concurrency = "${maxThread.modeling.modeling-call}"
+        concurrency = "${maxThread.modeling.modeling-call}",
+        priority = "${mq.consumerPriority}"
     )
-    public void buildSceneHandler(Channel channel, Message message) throws Exception {
-        Object correlation = message.getMessageProperties().getHeader("spring_returned_message_correlation");
-        String correlationId = (String) correlation;
+    public void buildSceneHandler(Channel channel, Message message, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag) throws Exception {
+        SysConstants.SYSTEM_BUILDING = true;
+        if (SysConstants.SYSTEM_OFFING) {
+            SysConstants.SYSTEM_BUILDING = false;
+            channel.basicNack(deliveryTag, true, true);
+            log.error("服务实例：{} 正在关闭，退出构建！", SysConstants.hostName);
+            return;
+        }
         if (ObjectUtils.isEmpty(message.getBody())) {
             SysConstants.SYSTEM_BUILDING = false;
-            log.error("消息体为空,退出构建,当前服务器:{}", SysConstants.hostName);
+            log.error("消息内容为空,退出构建,当前服务器id:{}", SysConstants.hostName);
             return;
         }
         String msg = new String(message.getBody(), StandardCharsets.UTF_8);
         BuildSceneCallMessage buildSceneMessage = JSONObject.parseObject(msg, BuildSceneCallMessage.class);
-        log.info("场景计算开始,队列名:{},id:{},消息体:{}", queueModelingCall, correlationId,msg);
+
+        Object correlation = message.getMessageProperties().getHeader("spring_returned_message_correlation");
+        String correlationId = (String) correlation;
         if(Objects.isNull(buildSceneMessage) || StrUtil.isBlank(buildSceneMessage.getSceneNum())){
             log.error("消息内容错误,id:{},消息体:{}", correlationId, msg);
             return;
         }
-
-        Thread.sleep(2000L);
+        log.info("场景计算开始,队列名:{},id:{},消息体:{}", queueModelingCall, correlationId,msg);
         this.process(buildSceneMessage);
-
-        log.info("场景计算开始,队列名:{},id:{}", queueModelingCall, correlationId);
+        log.info("场景计算结束,队列名:{},id:{}", queueModelingCall, correlationId);
 
         channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
+
+        //计算完毕，将当前系统构建状态改为false
+        SysConstants.SYSTEM_BUILDING = false;
     }
 
     public void process(BuildSceneCallMessage message) {
-
-        SysConstants.SYSTEM_BUILDING = true;
-        if (SysConstants.SYSTEM_OFFING) {
-            SysConstants.SYSTEM_BUILDING = false;
-            log.error("服务实例：{} 正在关闭，退出构建！", SysConstants.hostName);
-            throw new BusinessException(ServerCode.SERVER_CLOSING);
-        }
         //开始计时
         StopWatch watch = new StopWatch();
         watch.start();
 
         BuildLog buildLog = new BuildLog();
         final BuildSceneResultBean buildSceneResult = new BuildSceneResultBean();
-        Future<ModelingBuildStatus> future = null;
+        ModelingBuildStatus status = null;
         try {
 
             //休眠2秒等待准备数据
@@ -151,29 +143,30 @@ public class RabbitMqListener {
             //计算前准备
             preBuild(message, buildLog);
 
-            future = SysConstants.executorService.submit(()->{
-                return buildScene(message, buildSceneResult);
-            });
-            future.get(SysConstants.modelTimeOut, TimeUnit.HOURS);
+            Future<ModelingBuildStatus> future = SysConstants.executorService.submit(()-> buildScene(message, buildSceneResult));
+            status = future.get(SysConstants.modelTimeOut, TimeUnit.HOURS);
 
             //结束计时
             watch.stop();
             buildLog.setDuration(watch.getTime(TimeUnit.SECONDS));
         } catch (TimeoutException ex) {
             log.error("服务实例：{} 构建异常：",SysConstants.hostName,ex);
-            buildSceneResult.setBuildStatus(ModelingBuildStatus.OVERTIME);
+            status = ModelingBuildStatus.OVERTIME;
         } catch (BuildException e){
-            buildSceneResult.setBuildStatus(e.getBuildStatus());
+            status = e.getBuildStatus();
         } catch(Exception e) {
             log.error("服务实例：{} 构建异常：", SysConstants.hostName, e);
             if (e.getCause() instanceof BuildException) {
-                buildSceneResult.setBuildStatus(((BuildException) e.getCause()).getBuildStatus());
+                status = ((BuildException) e.getCause()).getBuildStatus();
+                buildLog.setBuildStatus(((BuildException) e.getCause()).getBuildStatus().code());
             } else {
-                buildSceneResult.setBuildStatus(ModelingBuildStatus.FAILED);
+                status = ModelingBuildStatus.FAILED;
                 //未知异常，记录异常信息
                 buildLog.setReason(ExceptionUtil.stacktraceToString(e, 3000));
             }
         }
+        buildLog.setBuildStatus(status.code());
+        buildSceneResult.setBuildStatus(status);
         //计算后处理
         afterBuild(message, buildSceneResult, buildLog);
 
@@ -299,7 +292,6 @@ public class RabbitMqListener {
             this.jgSynch(message);
         }
 
-        buildSceneResult.setBuildStatus(ModelingBuildStatus.SUCCESS);
         buildSceneResult.setFileId(fileId);
         buildSceneResult.setPayStatus(payStatus);
         buildSceneResult.setUploadMap(map);
@@ -315,11 +307,10 @@ public class RabbitMqListener {
     }
 
     private void afterBuild(BuildSceneCallMessage message, BuildSceneResultBean buildSceneResult, BuildLog buildLog){
+        ModelingBuildStatus buildStatus = null;
         try {
-            ModelingBuildStatus buildStatus = buildSceneResult.getBuildStatus();
-            String buildLogPath = String.format(UploadFilePath.BUILD_LOG_PATH, message.getSceneNum());
+            buildStatus = buildSceneResult.getBuildStatus();
             log.info("服务{} 计算结束:{},计算状态：{}", SysConstants.hostName, buildLog.getNum(),buildStatus.message());
-
             if(!buildStatus.equals(ModelingBuildStatus.REPEAT)){
                 //释放锁
                 redisUtil.del(String.format(RedisKey.SCENE_BUILDING, message.getSceneNum()));
@@ -329,21 +320,22 @@ public class RabbitMqListener {
                     message.getSceneNum(),message.getThumb(),message.getPayStatus(), message.getDataSource());
 
                 //如果是重复计算，没有走到计算逻辑，不需要上传日志文件
+                String buildLogPath = String.format(UploadFilePath.BUILD_LOG_PATH, message.getSceneNum());
                 buildLog.setLogDetailPath(prefixAli+ buildLogPath + "console.log");
             }
-            buildLog.setBuildStatus(buildStatus.code());
             buildLog.setCameraType(Integer.parseInt(buildSceneResult.getCameraType()));
             buildLogService.updateById(buildLog);
-
         } catch (Exception e) {
             log.error("计算后业务处理出错！", e);
         }finally {
             //发送计算结果mq
             buildSceneResult.setDuration(buildLog.getDuration());
             this.sendCallResult(message, buildSceneResult);
-
-            //计算完毕，将当前系统构建状态改为false
-            SysConstants.SYSTEM_BUILDING = false;
+            //如果是计算失败，需要发送钉钉
+            if(!ModelingBuildStatus.SUCCESS.equals(buildStatus)){
+                // TODO: 2022/1/25 测试阶段，先注释掉推送
+                this.sendDingTalkMq(buildStatus.message(), message);
+            }
         }
     }
 
@@ -354,7 +346,18 @@ public class RabbitMqListener {
         buildLog.setQueueName(queueModelingCall);
         buildLog.setNum(message.getSceneNum());
         buildLog.setDataSource(message.getDataSource());
+
+        // 设置缓存锁
+        String key = SysConstants.SCENE_BUILDING + buildLog.getNum();
+        // 获取缓存锁，防止重复消费
+        Long building = redisUtil.incr(key, 1);
         buildLogService.save(buildLog);
+        if (building.compareTo(1L) != 0) {
+            log.error("服务：{}，重复构建：{}",SysConstants.hostName,buildLog.getNum());
+            throw new BuildException(ModelingBuildStatus.REPEAT);
+        }else{
+            redisUtil.expire(key,SysConstants.modelTimeOut);
+        }
     }
 
     /**
@@ -368,10 +371,9 @@ public class RabbitMqListener {
         if(buildStatus.equals(ModelingBuildStatus.REPEAT)){
             return;
         }
-        boolean buildSuccess = buildStatus.equals(ModelingBuildStatus.SUCCESS) ? true : false;
         rabbitMqProducer.sendByWorkQueue(queueModelingPost,
             BuildSceneResultMqMessage.builder()
-                .buildSuccess(buildSuccess)
+                .buildSuccess(buildStatus.equals(ModelingBuildStatus.SUCCESS))
                 .cameraType(buildSceneResult.getCameraType())
                 .computeTime(buildSceneResult.getDuration())
                 .fileId(buildSceneResult.getFileId())
@@ -384,15 +386,9 @@ public class RabbitMqListener {
                 .prefix(buildSceneResult.getPrefix())
                 .videoVersion(buildSceneResult.getVideoVersion())
                 .build());
-        //如果是计算失败，需要发送钉钉
-        if(!buildSuccess){
-            // TODO: 2022/1/25 测试阶段，先注释掉推送
-//            this.sendDingTalkMq(buildStatus.message(), message);
-        }
     }
 
-    private void upoadLog(Integer sceneStatus, String webSite,
-        String num, String thumb, Integer payStatus, String dataSource){
+    private void upoadLog(Integer sceneStatus, String webSite, String num, String thumb, Integer payStatus, String dataSource){
         try{
             JSONObject statusJson = new JSONObject();
             //临时将-2改成1，app还没完全更新
@@ -413,16 +409,13 @@ public class RabbitMqListener {
             String buildLogPath = String.format(UploadFilePath.BUILD_LOG_PATH, num);
 
             //todo 待删除old_path
-            uploadToOssUtil.upload(
-                ConstantFilePath.SCENE_PATH + "data/data" + num + File.separator + "status.json",
+            uploadToOssUtil.upload(ConstantFilePath.SCENE_PATH + "data/data" + num + File.separator + "status.json",
                 "data/data" + num + File.separator + "status.json");
 
-            uploadToOssUtil.upload(
-                ConstantFilePath.SCENE_PATH + "data/data" + num + File.separator + "status.json",
+            uploadToOssUtil.upload(ConstantFilePath.SCENE_PATH + "data/data" + num + File.separator + "status.json",
                 dataPath + "status.json");
 
-            uploadToOssUtil.upload(dataSource + File.separator + "console.log",
-                buildLogPath + "console.log");
+            uploadToOssUtil.upload(dataSource + File.separator + "console.log", buildLogPath + "console.log");
 
         }catch (Exception e){
             log.error("上传日志失败！", e);

src/main/resources/bootstrap-test.yml

@@ -31,12 +31,6 @@ spring:
           - data-id: common-upload-config.yaml
             group: DEFAULT_GROUP
             refresh: true
-      discovery:
-        server-addr: 120.24.144.164:8848
-        namespace: 4dkankan-test
-        metadata:
-          management:
-            context-path: ${server.servlet.context-path}/actuator
 
 #management:
 #  endpoints:

src/main/resources/bootstrap.yml

@@ -1,3 +1,3 @@
 spring:
   profiles:
-    active: dev
+    active: test