实时调度优化

app.py

@@ -5,8 +5,17 @@ from equipment.truck import TruckInfo
 from equipment.excavator import ExcavatorInfo
 from equipment.dump import DumpInfo
 from dispatcher import Dispatcher, PreSchedule, DispatchSubmission
+from flask_caching import Cache
+
+config = {
+    "DEBUG": True,          # some Flask specific configs
+    "CACHE_TYPE": "SimpleCache",  # Flask-Caching related configs
+    "CACHE_DEFAULT_TIMEOUT": 300
+}
 
 app = Flask(__name__)
+app.config.from_mapping(config)
+cache = Cache(app)
 
 
 @app.route("/dispatch", methods=["POST"])
@@ -26,38 +35,52 @@ def dispatch_request():
     # 获取日志器
     logger = get_logger("zxt.request")
 
-    # 清空数据库缓存
-    session_mysql.commit()
-    session_mysql.flush()
+    try:
+
+        # 清空数据库缓存
+        session_mysql.commit()
+        session_mysql.flush()
+
+        # 清空数据库缓存
+        session_postgre.commit()
+        session_postgre.flush()
+    except Exception as es:
+        logger.error("数据库访问异常")
+        logger.error(es)
+        return jsonify(msg="未知异常, 请联系管理员", code=506)
 
-    # 清空数据库缓存
-    session_postgre.commit()
-    session_postgre.flush()
+    try:
 
-    # 全局参数更新
-    global_period_para_update()
+        # 全局参数更新
+        global_period_para_update()
+        # get_global_para_from_cache(cache)
 
-    # 实例化设备对象
-    dump = DumpInfo()
-    excavator = ExcavatorInfo()
-    truck = TruckInfo(dump, excavator)
+        # 实例化设备对象
+        dump = DumpInfo()
+        excavator = ExcavatorInfo()
+        truck = TruckInfo(dump, excavator)
 
-    # 实例化调度预测器
-    pre_sch = PreSchedule(truck, excavator, dump)
+        # 实例化调度预测器
+        pre_sch = PreSchedule(truck, excavator, dump)
 
-    # 实例化矿卡调度器
-    dispatcher = Dispatcher(dump, excavator, truck, pre_sch, True)
+        # 实例化矿卡调度器
+        dispatcher = Dispatcher(dump, excavator, truck, pre_sch, True)
 
-    # 周期更新
-    dispatcher.dispatcher_period_update()
+        # 周期更新
+        dispatcher.dispatcher_period_update()
+    except Exception as es:
+        logger.error("参数更新异常")
+        logger.error(es)
+        session_mysql.rollback()
+        session_postgre.rollback()
+        return jsonify(msg="未知异常, 请联系管理员", code=505)
 
     request_trucks = []
     try:
-
         request_trucks = dispatcher.group.group_dispatch_truck[group_id]
     except Exception as es:
         logger.error(es)
-        return jsonify(msg="派车计划生成失败", detail="调度分组异常",  code=1005)
+        return jsonify(msg="未知异常, 请联系管理员", code=504)
 
     try:
         # 更新周期参数
@@ -65,10 +88,10 @@ def dispatch_request():
 
         if get_value("dynamic_dump_num") * get_value("dynamic_excavator_num") == 0:
             # raise Exception("无动态派车计划可用")
-            return jsonify(msg="派车计划生成失败", detail="无动态派车计划可用", code=1003)
+            return jsonify(msg="未知异常, 请联系管理员", code=503)
         if get_value("dynamic_truck_num") == 0:
             # raise Exception("无动态派车可用矿卡")
-            return jsonify(msg="派车计划生成失败", detail="无动态派车可用矿卡", code=1004)
+            return jsonify(msg="未知异常, 请联系管理员", code=502)
 
         # 更新请调矿卡派车计划
         for truck_id in request_trucks:
@@ -80,11 +103,17 @@ def dispatch_request():
     except Exception as es:
         logger.error("最外层异常捕获")
         logger.error(es)
-        return jsonify(msg="派车计划生成失败", detail="未知异常",  code=1002)
+        return jsonify(msg="未知异常, 请联系管理员", code=501)
+
+    # DBsession_postgre.close_all()
+    # DBsession_mysql.close_all()
+
+    session_mysql.close()
+    session_postgre.close()
 
     # 调度结束时间
     rtd_end_time = datetime.now()
 
     print(f'调度时耗 {rtd_end_time - rtd_start_time}')
 
-    return jsonify(msg="派车计划生成成功", code=1001)
+    return jsonify(msg="success", code=0)
\ No newline at end of file

dispatcher.py

@@ -131,9 +131,17 @@ class Dispatcher(WalkManage):
         """
         # 规则读取
 
-        rule3 = session_mysql.query(DispatchRule).filter_by(id=3).first().disabled
+        try:
+
+            rule3 = session_mysql.query(DispatchRule).filter_by(id=3).first().disabled
+
+            rule4 = session_mysql.query(DispatchRule).filter_by(id=4).first().disabled
 
-        rule4 = session_mysql.query(DispatchRule).filter_by(id=4).first().disabled
+        except Exception as es:
+            self.logger.error(es)
+            self.logger.error("调度规则读取异常")
+            session_postgre.rollback()
+            session_postgre.rollback()
 
         try:
 
@@ -673,7 +681,7 @@ class DispatchSubmission:
                 self.logger.error(f"调度结果:{Seq}")
                 self.logger.error(es)
 
-        for i in range(dynamic_truck_num):
+        for i in range(get_value("dynamic_truck_num")):
             print("dispatch_setting:")
             print(redis5.get(self.truck.truck_index_to_uuid_dict[i]))
         # except Exception as es:

equipment/dump.py

@@ -124,8 +124,11 @@ class DumpInfo(WalkManage):
             except Exception as es:
                 self.logger.error("卸点物料更新异常")
                 self.logger.error(es)
+                session_mysql.rollback()
+                session_postgre.rollback()
 
     def update_dump_priority(self):
+        unload_area_index_to_uuid_dict = get_value("unload_area_index_to_uuid_dict")
         self.dump_priority_coefficient = np.ones(self.dynamic_dump_num)
         for dump_id in self.dynamic_dump_set:
             try:
@@ -140,15 +143,27 @@ class DumpInfo(WalkManage):
             except Exception as es:
                 self.logger.error("卸点优先级更新异常")
                 self.logger.error(es)
+                session_postgre.rollback()
 
     def update_unload_ability(self):
+        unload_area_index_to_uuid_dict = get_value("unload_area_index_to_uuid_dict")
         try:
-            rule3 = session_mysql.query(DispatchRule).filter_by(id=3).first()
+            try:
+                rule3 = session_mysql.query(DispatchRule).filter_by(id=3).first()
+            except Exception as es:
+                self.logger.error(es)
+                session_mysql.rollback()
+                session_postgre.rollback()
             if not rule3.disabled:
                 for dump_index in range(self.dynamic_dump_num):
                     unload_area_id = unload_area_index_to_uuid_dict[self.dump_index_to_unload_area_index_dict[dump_index]]
 
-                    unload_ability = session_postgre.query(DumpArea).filter_by(Id=unload_area_id).first().UnloadAbililty
+                    try:
+                        unload_ability = session_postgre.query(DumpArea).filter_by(Id=unload_area_id).first().UnloadAbililty
+                    except Exception as es:
+                        self.logger.error(es)
+                        session_mysql.rollback()
+                        session_postgre.rollback()
                     self.dump_strength[dump_index] = unload_ability  # 卸载设备最大卸载能力，单位吨/小时
 
                     if unload_ability < 200:

equipment/excavator.py

@@ -136,6 +136,8 @@ class ExcavatorInfo(WalkManage):
                 self.excavator_material[excavator_id] = excavator_material_id
             except Exception as es:
                 self.logger.warning(es)
+                session_postgre.rollback()
+                session_postgre.rollback()
 
     def update_excavator_priority(self):
 
@@ -143,38 +145,51 @@ class ExcavatorInfo(WalkManage):
         self.logger.info(self.dynamic_excavator_set)
 
         for excavator_id in get_value("dynamic_excavator_set"):
-            item = session_mysql.query(Equipment).filter_by(id=excavator_id).first()
-            self.logger.info("excavator_priority_coefficient")
-            self.logger.info(self.excavator_priority_coefficient)
-            self.excavator_priority_coefficient[self.excavator_uuid_to_index_dict[excavator_id]] = item.priority + 1
-
-            # 物料优先级控制
-            rule = 2
-            rule7 = session_mysql.query(DispatchRule).filter_by(id=7).first()
-
-            material_priority_use = rule7.disabled
-            if material_priority_use == 0:
-                rule = rule7.rule_weight
-
-            if rule == 3:
-                if self.excavator_material[excavator_id] == 'e56eb559-a746-4cc4-8ada-ebf9819fbe27':
-                    self.excavator_material_priority[self.excavator_uuid_to_index_dict[excavator_id]] = 5
-            elif rule == 1:
-                if self.excavator_material[excavator_id] == '81bb175d-50fe-4be3-937e-6791ac4d6fec':
-                    self.excavator_material_priority[self.excavator_uuid_to_index_dict[excavator_id]] = 5
-
+            try:
+                item = session_mysql.query(Equipment).filter_by(id=excavator_id).first()
+                self.logger.info("excavator_priority_coefficient")
+                self.logger.info(self.excavator_priority_coefficient)
+                self.excavator_priority_coefficient[self.excavator_uuid_to_index_dict[excavator_id]] = item.priority + 1
+
+                # 物料优先级控制
+                rule = 2
+                rule7 = session_mysql.query(DispatchRule).filter_by(id=7).first()
+
+                material_priority_use = rule7.disabled
+                if material_priority_use == 0:
+                    rule = rule7.rule_weight
+
+                if rule == 3:
+                    if self.excavator_material[excavator_id] == 'e56eb559-a746-4cc4-8ada-ebf9819fbe27':
+                        self.excavator_material_priority[self.excavator_uuid_to_index_dict[excavator_id]] = 5
+                elif rule == 1:
+                    if self.excavator_material[excavator_id] == '81bb175d-50fe-4be3-937e-6791ac4d6fec':
+                        self.excavator_material_priority[self.excavator_uuid_to_index_dict[excavator_id]] = 5
+            except Exception as es:
+                self.logger.error("物料更新异常")
+                self.logger.error(es)
+                session_postgre.rollback()
+                session_postgre.rollback()
     def update_mining_ability(self):
         try:
-            rule4 = session_mysql.query(DispatchRule).filter_by(id=4).first()
+            try:
+                rule4 = session_mysql.query(DispatchRule).filter_by(id=4).first()
+            except Exception as es:
+                session_postgre.rollback()
+                session_postgre.rollback()
             if not rule4.disabled:
                 for excavator_index in range(len(self.excavator_index_to_uuid_dict)):
-                    load_ability = session_mysql.query(EquipmentSpec.mining_abililty).\
-                        join(Equipment, Equipment.equipment_spec == EquipmentSpec.id).\
-                        filter(Equipment.id == self.excavator_index_to_uuid_dict[excavator_index]).first()
-                    self.excavator_strength[excavator_index] = load_ability.mining_abililty
-
-                    # if load_ability.mining_abililty < 200:
-                    #     raise Exception("挖机装载能力异常")
+                    try:
+                        load_ability = session_mysql.query(EquipmentSpec.mining_abililty).\
+                            join(Equipment, Equipment.equipment_spec == EquipmentSpec.id).\
+                            filter(Equipment.id == self.excavator_index_to_uuid_dict[excavator_index]).first()
+                        self.excavator_strength[excavator_index] = load_ability.mining_abililty
+
+                        # if load_ability.mining_abililty < 200:
+                        #     raise Exception("挖机装载能力异常")
+                    except Exception as es:
+                        session_postgre.rollback()
+                        session_postgre.rollback()
             else:
                 self.excavator_strength = np.full(self.dynamic_excavator_num, 5000)
 
@@ -209,7 +224,11 @@ class ExcavatorInfo(WalkManage):
 
         self.logger.info("Excavator update!")
 
-        rule7 = session_mysql.query(DispatchRule).filter_by(id=7).first().disabled
+        try:
+            rule7 = session_mysql.query(DispatchRule).filter_by(id=7).first().disabled
+        except Exception as es:
+            session_postgre.rollback()
+            session_postgre.rollback()
 
         self.logger.info("物料优先级规则")
         self.logger.info(rule7)

equipment/truck.py

@@ -127,6 +127,8 @@ class TruckInfo(WalkManage):
         self.truck_current_task = {}
         device_name_set = redis2.keys()
 
+        truck_name_to_uuid_dict = get_value("truck_name_to_uuid_dict")
+
         for item in device_name_set:
             try:
                 item = item.decode(encoding="utf-8")
@@ -176,7 +178,7 @@ class TruckInfo(WalkManage):
         self.relative_last_unload_time = {}
 
         try:
-
+            truck_uuid_to_name_dict = get_value("truck_uuid_to_name_dict")
             for item in self.dynamic_truck_set:
                 key_value_dict = redis2.hgetall(truck_uuid_to_name_dict[item])
                 device_type = int(key_value_dict[str_to_byte("type")])
@@ -273,9 +275,14 @@ class TruckInfo(WalkManage):
             except Exception as es:
                 self.logger.error("配对关系异常")
                 self.logger.error(es)
+                session_postgre.rollback()
+                session_postgre.rollback()
                 continue
 
             try:
+                load_area_uuid_to_index_dict = get_value("load_area_uuid_to_index_dict")
+                unload_area_uuid_to_index_dict = get_value("unload_area_uuid_to_index_dict")
+
                 # 若矿卡状态为空运
                 if task in [0, 1, 2]:    # 矿卡空载或仍未出装载区
                     last_unload_time = self.relative_last_unload_time[
@@ -388,6 +395,8 @@ class TruckInfo(WalkManage):
             except Exception as es:
                 self.logger.error("配对关系异常")
                 self.logger.error(es)
+                session_postgre.rollback()
+                session_postgre.rollback()
                 continue
 
             try:
@@ -448,22 +457,37 @@ class TruckInfo(WalkManage):
 
     def update_truck_priority(self):
         self.truck_priority = np.full(self.dynamic_truck_num, 0)
+        try:
+            rule6 = session_mysql.query(DispatchRule).filter_by(id=6).first()
+        except Exception as es:
+            session_postgre.rollback()
+            session_postgre.rollback()
 
-        rule6 = session_mysql.query(DispatchRule).filter_by(id=6).first()
-        if rule6.disabled == 0:
-            for truck_id in self.dynamic_truck_set:
-                item = session_mysql.query(Equipment).filter_by(id=truck_id).first()
-                truck_index = self.truck_uuid_to_index_dict[truck_id]
-                if item.priority == 0:
-                    self.truck_priority[truck_index] = 0
-                elif item.priority == 1:
-                    self.truck_priority[truck_index] = 2
-                elif item.priority == 2:
-                    self.truck_priority[truck_index] = 5
-                elif item.priority == 3:
-                    self.truck_priority[truck_index] = 10
+        try:
+            if rule6.disabled == 0:
+                for truck_id in self.dynamic_truck_set:
+                    try:
+                        item = session_mysql.query(Equipment).filter_by(id=truck_id).first()
+                    except Exception as es:
+                        session_postgre.rollback()
+                        session_postgre.rollback()
+                    truck_index = self.truck_uuid_to_index_dict[truck_id]
+                    if item.priority == 0:
+                        self.truck_priority[truck_index] = 0
+                    elif item.priority == 1:
+                        self.truck_priority[truck_index] = 2
+                    elif item.priority == 2:
+                        self.truck_priority[truck_index] = 5
+                    elif item.priority == 3:
+                        self.truck_priority[truck_index] = 10
+        except Exception as es:
+            self.logger.error("车辆优先级更新异常")
+            self.logger.error(es)
+            session_postgre.rollback()
+            session_postgre.rollback()
 
     def update_truck_dump_area_bind(self):
+        truck_name_to_uuid_dict = get_value("truck_name_to_uuid_dict")
         try:
             rule5 = session_mysql.query(DispatchRule).filter_by(id=5).first()
             if rule5.disabled == 0:
@@ -477,8 +501,11 @@ class TruckInfo(WalkManage):
         except Exception as es:
             self.logger.error("矿卡-卸载区域绑定关系读取异常")
             self.logger.error(es)
+            session_postgre.rollback()
+            session_postgre.rollback()
 
     def update_truck_excavator_bind(self):
+        truck_name_to_uuid_dict = get_value("truck_name_to_uuid_dict")
         try:
             rule5 = session_mysql.query(DispatchRule).filter_by(id=5).first()
             if rule5.disabled == 0:
@@ -493,24 +520,36 @@ class TruckInfo(WalkManage):
         except Exception as es:
             self.logger.error("矿卡-挖机绑定关系读取异常")
             self.logger.error(es)
+            session_postgre.rollback()
+            session_postgre.rollback()
 
     def update_truck_excavator_exclude(self):
 
         self.truck_excavator_exclude = {}
 
+        truck_uuid_to_name_dict = get_value("truck_uuid_to_name_dict")
+
         self.excavator_exclude_modify = np.full(
             (self.dynamic_truck_num, get_value("dynamic_excavator_num")), 0
         )
 
         try:
-            rule5 = session_mysql.query(DispatchRule).filter_by(id=5).first()
+            try:
+                rule5 = session_mysql.query(DispatchRule).filter_by(id=5).first()
+            except Exception as es:
+                session_postgre.rollback()
+                session_postgre.rollback()
             if rule5.disabled == 0:
                 for excavator_id in get_value("dynamic_excavator_set"):
-                    item = (
-                        session_mysql.query(Equipment)
-                            .filter_by(id=excavator_id, only_allowed=1)
-                            .first()
-                    )
+                    try:
+                        item = (
+                            session_mysql.query(Equipment)
+                                .filter_by(id=excavator_id, only_allowed=1)
+                                .first()
+                        )
+                    except Exception as es:
+                        session_postgre.rollback()
+                        session_postgre.rollback()
                     if item is not None:
                         for truck_id in self.dynamic_truck_set:
                             if truck_uuid_to_name_dict[truck_id] not in item.bind_list:
@@ -544,7 +583,11 @@ class TruckInfo(WalkManage):
 
                 if truck_id in self.truck_dump_bind:
                     unload_area_id = self.truck_dump_bind[truck_id]
-                    dump_material_id = session_postgre.query(DumpArea).filter_by(Id=unload_area_id).first().Material
+                    try:
+                        dump_material_id = session_postgre.query(DumpArea).filter_by(Id=unload_area_id).first().Material
+                    except Exception as es:
+                        session_postgre.rollback()
+                        session_postgre.rollback()
                     self.truck_material_bind[truck_id] = dump_material_id
 
                 if truck_id in self.truck_excavator_bind:
@@ -579,27 +622,51 @@ class TruckInfo(WalkManage):
 
     def update_truck_spec(self):
         for truck_id in self.dynamic_truck_set:
-            self.size[truck_id] = session_mysql.query(Equipment).filter_by(id=truck_id).first().equipment_spec
+            try:
+                self.size[truck_id] = session_mysql.query(Equipment).filter_by(id=truck_id).first().equipment_spec
+            except Exception as es:
+                self.logger.error("车辆型号更新异常")
+                self.logger.error(es)
+                session_postgre.rollback()
+                session_postgre.rollback()
 
     def update_truck_size(self):
         self.update_truck_spec()
         for truck_id in self.dynamic_truck_set:
             truck_spec_id = self.size[truck_id]
-            self.geo_length[truck_id] = session_mysql.query(EquipmentSpec).filter_by(id=truck_spec_id).first().length
-            self.geo_width[truck_spec_id] = session_mysql.query(EquipmentSpec).filter_by(id=truck_spec_id).first().width
+            try:
+                self.geo_length[truck_id] = session_mysql.query(EquipmentSpec).filter_by(id=truck_spec_id).first().length
+                self.geo_width[truck_spec_id] = session_mysql.query(EquipmentSpec).filter_by(id=truck_spec_id).first().width
+            except Exception as es:
+                self.logger.error("车辆几何尺寸更新异常")
+                self.logger.error(es)
+                session_postgre.rollback()
+                session_postgre.rollback()
 
     def update_truck_speed(self):
         for truck_id in self.dynamic_truck_set:
-            self.empty_speed[truck_id] = session_mysql.query(EquipmentSpec). \
-                join(Equipment, EquipmentSpec.id == Equipment.equipment_spec). \
-                filter(Equipment.id == truck_id).first().max_speed
-            self.heavy_speed[truck_id] = session_mysql.query(EquipmentSpec). \
-                join(Equipment, EquipmentSpec.id == Equipment.equipment_spec). \
-                filter(Equipment.id == truck_id).first().max_speed
+            try:
+                self.empty_speed[truck_id] = session_mysql.query(EquipmentSpec). \
+                    join(Equipment, EquipmentSpec.id == Equipment.equipment_spec). \
+                    filter(Equipment.id == truck_id).first().max_speed
+                self.heavy_speed[truck_id] = session_mysql.query(EquipmentSpec). \
+                    join(Equipment, EquipmentSpec.id == Equipment.equipment_spec). \
+                    filter(Equipment.id == truck_id).first().max_speed
+            except Exception as es:
+                self.logger.error("车辆速度更新异常")
+                self.logger.error(es)
+                session_postgre.rollback()
+                session_postgre.rollback()
 
     def update_truck_disable_list(self) -> List:
-        for item in session_mysql.query(Equipment).filter_by(device_type=1, disabled=1).all():
-            self.truck_disable_list.append(item.equipment_id)
+        try:
+            for item in session_mysql.query(Equipment).filter_by(device_type=1, disabled=1).all():
+                self.truck_disable_list.append(item.equipment_id)
+        except Exception as es:
+            self.logger.error("车辆禁止列表更新异常")
+            self.logger.error(es)
+            session_postgre.rollback()
+            session_postgre.rollback()
         return self.truck_disable_list
 
     def truck_reset(self, dump, excavator):
@@ -640,70 +707,33 @@ class TruckInfo(WalkManage):
         # 初始化参数
         self.truck_reset(dump, excavator)
 
-        # 距离成本启动
-        rule1 = session_mysql.query(DispatchRule).filter_by(id=1).first().disabled
+        try:
 
-        # 拥堵成本启用
-        rule2 = session_mysql.query(DispatchRule).filter_by(id=2).first().disabled
+            # 距离成本启动
+            rule1 = session_mysql.query(DispatchRule).filter_by(id=1).first().disabled
 
-        # 车流规划启用
-        rule3 = session_mysql.query(DispatchRule).filter_by(id=3).first().disabled
+            # 拥堵成本启用
+            rule2 = session_mysql.query(DispatchRule).filter_by(id=2).first().disabled
 
-        rule4 = session_mysql.query(DispatchRule).filter_by(id=4).first().disabled
+            # 车流规划启用
+            rule3 = session_mysql.query(DispatchRule).filter_by(id=3).first().disabled
 
-        # 锁定禁止启用
-        rule5 = session_mysql.query(DispatchRule).filter_by(id=5).first().disabled
+            rule4 = session_mysql.query(DispatchRule).filter_by(id=4).first().disabled
 
-        # 设备优先级启用
-        rule6 = session_mysql.query(DispatchRule).filter_by(id=6).first().disabled
+            # 锁定禁止启用
+            rule5 = session_mysql.query(DispatchRule).filter_by(id=5).first().disabled
 
-        # self.logger.info("Para truck update!")
-        #
-        # # 装载周期参数
-        # self.period_map_para_load()
-        #
-        # self.period_walk_para_load()
-        #
-        # # 更新有效载重
-        # self.update_truck_payload()
-        #
-        # self.logger.info("距离成本规则")
-        # self.logger.info(rule1)
-        #
-        # self.logger.info("拥堵成本规则")
-        # self.logger.info(rule2)
-        #
-        # self.logger.info("车流规划规则")
-        # self.logger.info(rule3 or rule4)
-        #
-        # self.logger.info("生产组织规则")
-        # self.logger.info(rule5)
-        #
-        # self.logger.info("设备优先级规则")
-        # self.logger.info(rule6)
-        #
-        # if not rule5:
-        #     # 更新绑定关系
-        #     self.update_truck_dump_area_bind()
-        #
-        #     self.update_truck_excavator_bind()
-        #
-        #     # 更新禁止关系
-        #     self.update_truck_excavator_exclude()
-        #
-        # if not rule6:
-        #     # 更新矿卡调度优先级
-        #     self.update_truck_priority()
-        #
-        # # # 更新矿卡group
-        # # self.update_truck_group()
-        #
-        # # 更新矿卡物料类型
-        # self.update_truck_material()
+            # 设备优先级启用
+            rule6 = session_mysql.query(DispatchRule).filter_by(id=6).first().disabled
 
+            # 物料优先级启用
+            rule7 = session_mysql.query(DispatchRule).filter_by(id=7).first().disabled
 
-        # 物料优先级启用
-        rule7 = session_mysql.query(DispatchRule).filter_by(id=7).first().disabled
+        except Exception as es:
+            self.logger.error("规则读取异常")
+            self.logger.error(es)
+            session_postgre.rollback()
+            session_postgre.rollback()
 
         self.logger.info("Para truck update!")
 

group_control/group_control.py

@@ -70,7 +70,12 @@ class Group(WalkManage):
 
         # 动态派车数量没变，但是此时某条派车计划被删除，dispatch_truck_group 就会缺失矿卡
         for truck_id in dynamic_truck_set:
-            item = session_mysql.query(Dispatch).filter_by(truck_id=truck_id, isauto=1, isdeleted=0).first()
+            try:
+                item = session_mysql.query(Dispatch).filter_by(truck_id=truck_id, isauto=1, isdeleted=0).first()
+            except Exception as es:
+                self.logger.error(es)
+                session_postgre.rollback()
+                session_postgre.rollback()
             if item is None:
                 print(truck_id)
                 continue
@@ -90,9 +95,13 @@ class Group(WalkManage):
         """
         # 更新调度组
         self.group_set = set()
-        for item in session_mysql.query(Dispatch).filter_by(isauto=1, isdeleted=0).all():
-            if item.group_id is not None:
-                self.group_set.add(item.group_id)
+        try:
+            for item in session_mysql.query(Dispatch).filter_by(isauto=1, isdeleted=0).all():
+                if item.group_id is not None:
+                    self.group_set.add(item.group_id)
+        except Exception as es:
+            session_postgre.rollback()
+            session_postgre.rollback()
         self.group_num = len(self.group_set)
 
     def update_device_group(self):
@@ -106,9 +115,13 @@ class Group(WalkManage):
                 self.device_group[group_id] = [set(), set()]
             else:
                 continue
-            for item in session_mysql.query(Dispatch).filter_by(group_id=group_id, isauto=1, isdeleted=0).all():
-                self.device_group[group_id][0].add(item.dump_id)
-                self.device_group[group_id][1].add(item.exactor_id)
+            try:
+                for item in session_mysql.query(Dispatch).filter_by(group_id=group_id, isauto=1, isdeleted=0).all():
+                    self.device_group[group_id][0].add(item.dump_id)
+                    self.device_group[group_id][1].add(item.exactor_id)
+            except Exception as es:
+                session_postgre.rollback()
+                session_postgre.rollback()
 
     def update_actual_traffic_flow(self):
         """
@@ -232,6 +245,7 @@ class Group(WalkManage):
         """
 
         walk_to_excavator_cost, walk_to_dump_cost, park_to_excavator_cost = self.path.walk_cost_cal()
+        park_num = get_value("park_num")
 
         try:
 

para_config.py

@@ -26,60 +26,60 @@ M = 100000000
 
 logger = get_logger("zxt.para")
 
-# 装载区、卸载区、备停区在调度算法运行器件默认不发生改变，提前计算部分参量
-# (uuid,index(id)映射关系, 装载区数量, 卸载区数量, 备停区数量, 以及初次统计动态调度矿卡)
-(
-    load_area_uuid_to_index_dict,
-    unload_area_uuid_to_index_dict,
-    load_area_index_to_uuid_dict,
-    unload_area_index_to_uuid_dict,
-) = build_work_area_uuid_index_map()
-
-load_area_num, unload_area_num = len(load_area_uuid_to_index_dict), len(
-    unload_area_uuid_to_index_dict
-)
-
-park_uuid_to_index_dict, park_index_to_uuid_dict = build_park_uuid_index_map()
-
-park_num = len(park_uuid_to_index_dict)
-
-truck_uuid_to_name_dict, truck_name_to_uuid_dict = build_truck_uuid_name_map()
-
-excavator_uuid_to_name_dict, dump_uuid_to_name_dict = build_equipment_uuid_name_map()
-
-# 矿卡集合
-truck_set = set(update_total_truck())
-
-# 固定派车矿卡集合
-fixed_truck_set = set(update_fixdisp_truck())
-
-# 动态派车矿卡集合
-# dynamic_truck_set = truck_set.difference(fixed_truck_set)
-dynamic_truck_set = update_dynamic_truck()
-
-dynamic_truck_num = len(dynamic_truck_set)
-
-logger.info("可用于动态派车的矿卡：")
-logger.info(dynamic_truck_set)
-
-# 用于动态调度的挖机及卸载设备
-dynamic_excavator_set = set(update_autodisp_excavator())
-dynamic_excavator_num = len(dynamic_excavator_set)
-
-dynamic_dump_set = set(update_autodisp_dump())
-dynamic_dump_num = len(dynamic_dump_set)
-
-global global_dict
+# # 装载区、卸载区、备停区在调度算法运行器件默认不发生改变，提前计算部分参量
+# # (uuid,index(id)映射关系, 装载区数量, 卸载区数量, 备停区数量, 以及初次统计动态调度矿卡)
+# (
+#     load_area_uuid_to_index_dict,
+#     unload_area_uuid_to_index_dict,
+#     load_area_index_to_uuid_dict,
+#     unload_area_index_to_uuid_dict,
+# ) = build_work_area_uuid_index_map()
+#
+# load_area_num, unload_area_num = len(load_area_uuid_to_index_dict), len(
+#     unload_area_uuid_to_index_dict
+# )
+#
+# park_uuid_to_index_dict, park_index_to_uuid_dict = build_park_uuid_index_map()
+#
+# park_num = len(park_uuid_to_index_dict)
+#
+# truck_uuid_to_name_dict, truck_name_to_uuid_dict = build_truck_uuid_name_map()
+#
+# excavator_uuid_to_name_dict, dump_uuid_to_name_dict = build_equipment_uuid_name_map()
+#
+# # 矿卡集合
+# truck_set = set(update_total_truck())
+#
+# # 固定派车矿卡集合
+# fixed_truck_set = set(update_fixdisp_truck())
+#
+# # 动态派车矿卡集合
+# # dynamic_truck_set = truck_set.difference(fixed_truck_set)
+# dynamic_truck_set = update_dynamic_truck()
+#
+# dynamic_truck_num = len(dynamic_truck_set)
+#
+# logger.info("可用于动态派车的矿卡：")
+# logger.info(dynamic_truck_set)
+#
+# # 用于动态调度的挖机及卸载设备
+# dynamic_excavator_set = set(update_autodisp_excavator())
+# dynamic_excavator_num = len(dynamic_excavator_set)
+#
+# dynamic_dump_set = set(update_autodisp_dump())
+# dynamic_dump_num = len(dynamic_dump_set)
+#
+# global global_dict
 
 global_dict = {}
 
-global_dict["dynamic_truck_set"] = dynamic_truck_set
-global_dict["dynamic_truck_num"] = dynamic_truck_num
-global_dict["dynamic_excavator_set"] = dynamic_excavator_set
-global_dict["dynamic_excavator_num"] = dynamic_excavator_num
-global_dict["dynamic_dump_set"] = dynamic_dump_set
-global_dict["dynamic_dump_num"] = dynamic_dump_num
-global_dict["park_num"] = park_num
+# global_dict["dynamic_truck_set"] = dynamic_truck_set
+# global_dict["dynamic_truck_num"] = dynamic_truck_num
+# global_dict["dynamic_excavator_set"] = dynamic_excavator_set
+# global_dict["dynamic_excavator_num"] = dynamic_excavator_num
+# global_dict["dynamic_dump_set"] = dynamic_dump_set
+# global_dict["dynamic_dump_num"] = dynamic_dump_num
+# global_dict["park_num"] = park_num
 
 
 def get_value(name):
@@ -246,20 +246,20 @@ class WalkManage(DeviceMap):
     # # 工作区和设备不具备一一对应关系, 为方便就计算, 算法维护两套路网: 面向路网和面向设备
 
     # 路网真实距离
-    walk_time_to_excavator = np.full((dynamic_dump_num, dynamic_excavator_num), M, dtype=float)
-    walk_time_to_dump = np.full((dynamic_dump_num, dynamic_excavator_num), M, dtype=float)
-    walk_time_park_to_excavator = np.full((park_num, dynamic_excavator_num), M, dtype=float)
-    walk_time_park_to_load_area = np.full((park_num, load_area_num), M, dtype=float)
-    walk_time_to_load_area = np.full((unload_area_num, load_area_num), M, dtype=float)
-    walk_time_to_unload_area = np.full((unload_area_num, load_area_num), M, dtype=float)
+    walk_time_to_excavator = None
+    walk_time_to_dump = None
+    walk_time_park_to_excavator = None
+    walk_time_park_to_load_area = None
+    walk_time_to_load_area = None
+    walk_time_to_unload_area = None
 
     # 路网行驶时间
-    distance_to_excavator = np.full((dynamic_dump_num, dynamic_excavator_num), M, dtype=float)
-    distance_to_dump = np.full((dynamic_dump_num, dynamic_excavator_num), M, dtype=float)
-    distance_park_to_excavator = np.full((park_num, dynamic_excavator_num), M, dtype=float)
-    distance_park_to_load_area = np.full((park_num, load_area_num), M, dtype=float)
-    distance_to_load_area = np.full((unload_area_num, load_area_num), M, dtype=float)
-    distance_to_unload_area = np.full((unload_area_num, load_area_num), M, dtype=float)
+    distance_to_excavator = None
+    distance_to_dump = None
+    distance_park_to_excavator = None
+    distance_park_to_load_area = None
+    distance_to_load_area = None
+    distance_to_unload_area = None
 
     # def get_walk_time_to_load_area(cls):
     #     return cls.walk_time_to_load_area
@@ -352,6 +352,8 @@ class WalkManage(DeviceMap):
         except Exception as es:
             logger.error("路网信息异常")
             logger.error(es)
+            session_postgre.rollback()
+            session_postgre.rollback()
 
         # 计算设备路网距离及行走时间
         try:
@@ -388,6 +390,8 @@ class WalkManage(DeviceMap):
         except Exception as es:
             logger.error("备停区路网信息异常")
             logger.error(es)
+            session_postgre.rollback()
+            session_postgre.rollback()
         try:
             for i in range(park_num):
                 for j in range(dynamic_excavator_num):
@@ -407,6 +411,21 @@ class WalkManage(DeviceMap):
         logger.info(cls.distance_park_to_excavator)
 
 
+def get_global_para_from_cache(cache):
+    """ 优先从cache缓存读取global数据
+    :param cache: 缓存器
+    :return: None
+    """
+    global global_dict
+
+    global_dict = cache.get("global_dict")
+
+    if global_dict is None:
+        print("here2")
+        global_period_para_update()
+        cache.set("global_dict", global_dict, timeout=5 * 60)
+
+
 def global_period_para_update():
     global load_area_uuid_to_index_dict, load_area_index_to_uuid_dict
     global unload_area_uuid_to_index_dict, unload_area_index_to_uuid_dict
@@ -415,6 +434,7 @@ def global_period_para_update():
     global truck_uuid_to_name_dict, truck_name_to_uuid_dict
     global dynamic_truck_num, dynamic_excavator_num, dynamic_dump_num
     global excavator_uuid_to_name_dict, dump_uuid_to_name_dict
+    global global_dict
 
     # 清空数据库缓存
     session_mysql.commit()
@@ -441,6 +461,17 @@ def global_period_para_update():
 
     excavator_uuid_to_name_dict, dump_uuid_to_name_dict = build_equipment_uuid_name_map()
 
+    global_dict = {"park_num": park_num, "load_area_num": load_area_num, "unload_area_num": unload_area_num,
+                   "truck_uuid_to_name_dict": truck_uuid_to_name_dict,
+                   "truck_name_to_uuid_dict": truck_name_to_uuid_dict,
+                   "excavator_uuid_to_name_dict": excavator_uuid_to_name_dict,
+                   "dump_uuid_to_name_dict": dump_uuid_to_name_dict,
+                   "unload_area_uuid_to_index_dict": unload_area_uuid_to_index_dict,
+                   "load_area_uuid_to_index_dict": load_area_uuid_to_index_dict,
+                   "unload_area_index_to_uuid_dict": unload_area_index_to_uuid_dict,
+                   "park_uuid_to_index_dict": park_uuid_to_index_dict,
+                   "park_index_to_uuid_dict": park_index_to_uuid_dict}
+
     # 矿卡集合
     truck_set = set(update_total_truck())
 
@@ -456,9 +487,11 @@ def global_period_para_update():
     # 动态派车矿卡集合
     # dynamic_truck_set = truck_set.difference(fixed_truck_set)
     dynamic_truck_set = update_dynamic_truck()
-
     dynamic_truck_num = len(dynamic_truck_set)
 
+    global_dict["dynamic_truck_set"] = dynamic_truck_set
+    global_dict["dynamic_truck_num"] = dynamic_truck_num
+
     logger.info("可用于动态派车的矿卡：")
     logger.info(dynamic_truck_num)
     logger.info(dynamic_truck_set)
@@ -470,6 +503,11 @@ def global_period_para_update():
     dynamic_dump_set = set(update_autodisp_dump())
     dynamic_dump_num = len(dynamic_dump_set)
 
+    global_dict["dynamic_excavator_set"] = dynamic_excavator_set
+    global_dict["dynamic_excavator_num"] = dynamic_excavator_num
+    global_dict["dynamic_dump_set"] = dynamic_dump_set
+    global_dict["dynamic_dump_num"] = dynamic_dump_num
+
     DeviceMap.reset()
 
     DeviceMap.period_map_para_update()
@@ -478,24 +516,6 @@ def global_period_para_update():
 
     WalkManage.period_walk_para_update()
 
-    global_dict["dynamic_truck_set"] = dynamic_truck_set
-    global_dict["dynamic_truck_num"] = dynamic_truck_num
-    global_dict["dynamic_excavator_set"] = dynamic_excavator_set
-    global_dict["dynamic_excavator_num"] = dynamic_excavator_num
-    global_dict["dynamic_dump_set"] = dynamic_dump_set
-    global_dict["dynamic_dump_num"] = dynamic_dump_num
-    global_dict["park_num"] = park_num
-    global_dict["load_area_num"] = load_area_num
-    global_dict["unload_area_num"] = unload_area_num
-
-    global_dict["truck_uuid_to_name_dict"] = truck_uuid_to_name_dict
-    global_dict["excavator_uuid_to_name_dict"] = excavator_uuid_to_name_dict
-    global_dict["dump_uuid_to_name_dict"] = dump_uuid_to_name_dict
-    global_dict["unload_area_uuid_to_index_dict"] = unload_area_uuid_to_index_dict
-    global_dict["unload_area_index_to_uuid_dict"] = unload_area_index_to_uuid_dict
-    global_dict["park_uuid_to_index_dict"] = park_uuid_to_index_dict
-    global_dict["park_index_to_uuid_dict"] = park_index_to_uuid_dict
-
     global_dict["distance_to_excavator"] = WalkManage.distance_to_excavator
     global_dict["distance_park_to_excavator"] = WalkManage.distance_park_to_excavator
     global_dict["distance_to_dump"] = WalkManage.distance_to_dump

path_plan/path_planner_2.py

@@ -200,6 +200,9 @@ class PathPlanner(WalkManage):
         self.lane.lane_speed_generate()
 
         try:
+            unload_area_uuid_to_index_dict = get_value("unload_area_uuid_to_index_dict")
+            load_area_uuid_to_index_dict = get_value("load_area_uuid_to_index_dict")
+            park_uuid_to_index_dict = get_value(" park_uuid_to_index_dict")
             # 读取路网成本
             for walk_time in session_postgre.query(WalkTime).all():
                 load_area_id, unload_area_id = str(walk_time.load_area_id), str(walk_time.unload_area_id)

path_plan/path_plannner.py

@@ -32,7 +32,7 @@ class PathPlanner(WalkManage):
         self.controller = PriorityController(self.dump, self.excavator, self.truck)
 
         # 路线行驶成本
-        self.rout_cost = np.array((unload_area_num, load_area_num))
+        self.rout_cost = np.array((get_value("unload_area_num"), get_value("load_area_num")))
         # 路段集合
         self.lane_set = {}
         # 车辆长度(暂)
@@ -87,9 +87,12 @@ class PathPlanner(WalkManage):
             # 备停区处理
             if is_park:
                 # 提取指定道路记录
-                path = session_postgre.query(WalkTimePark).filter_by(park_area_id=unload_area_id,
+                try:
+                    path = session_postgre.query(WalkTimePark).filter_by(park_area_id=unload_area_id,
                                                                      load_area_id=load_area_id).first()
-
+                except Exception as es:
+                    session_postgre.rollback()
+                    session_postgre.rollback()
                 # 读取道路路段信息
                 for lane_id in path.park_load_lanes:
                     if lane_id in self.lane.used_lane_set:
@@ -104,9 +107,12 @@ class PathPlanner(WalkManage):
                 to_load_cost = alpha * cost_to_load_blockage + beta * path.park_load_distance
 
             else:
-                path = session_postgre.query(WalkTime).filter_by(load_area_id=load_area_id,
-                                                                 unload_area_id=unload_area_id).first()
-
+                try:
+                    path = session_postgre.query(WalkTime).filter_by(load_area_id=load_area_id,
+                                                                     unload_area_id=unload_area_id).first()
+                except Exception as es:
+                    session_postgre.rollback()
+                    session_postgre.rollback()
                 for lane_id in path.to_unload_lanes:
                     if lane_id in self.lane.used_lane_set:
                         if lane_id in lane_cost_memory:
@@ -146,7 +152,11 @@ class PathPlanner(WalkManage):
         lane_blockage = 0  # 路段拥堵度默认为0
 
         try:
-            lane_rec = session_postgre.query(Lane).filter_by(Id=lane_id).first()  # 读取路段记录
+            try:
+                lane_rec = session_postgre.query(Lane).filter_by(Id=lane_id).first()  # 读取路段记录
+            except Exception as es:
+                session_postgre.rollback()
+                session_postgre.rollback()
 
             lane_length = lane_rec.Length  # 道路长度
 
@@ -180,37 +190,56 @@ class PathPlanner(WalkManage):
         lane_cost_memory = {}  # 路段拥堵度列表, 记忆化搜索
 
         # 距离成本启用
-        rule1 = session_mysql.query(DispatchRule).filter_by(id=1).first()
+        try:
+            rule1 = session_mysql.query(DispatchRule).filter_by(id=1).first()
+        except Exception as es:
+            session_postgre.rollback()
+            session_postgre.rollback()
         if rule1.disabled == 0:
             beta = rule1.rule_weight
 
         # 拥堵成本启用
-        rule2 = session_mysql.query(DispatchRule).filter_by(id=2).first()
+        try:
+            rule2 = session_mysql.query(DispatchRule).filter_by(id=2).first()
+        except Exception as es:
+            session_postgre.rollback()
+            session_postgre.rollback()
         if rule2.disabled == 0:
             alpha = rule2.rule_weight
 
         try:
+            unload_area_uuid_to_index_dict = get_value("unload_area_uuid_to_index_dict")
+            load_area_uuid_to_index_dict = get_value("load_area_uuid_to_index_dict")
+            park_uuid_to_index_dict = get_value("park_uuid_to_index_dict")
             # 读取路网成本
-            for walk_time in session_postgre.query(WalkTime).all():
-                load_area_id, unload_area_id = str(walk_time.load_area_id), str(walk_time.unload_area_id)
-                unload_area_index = unload_area_uuid_to_index_dict[unload_area_id]
-                load_area_index = load_area_uuid_to_index_dict[load_area_id]
-                self.cost_to_load_area[unload_area_index][load_area_index], \
-                self.cost_to_unload_area[unload_area_index][load_area_index] = \
-                    self.path_cost_generate(load_area_id, unload_area_id, False, lane_cost_memory, alpha, beta)
-                # self.cost_to_load_area[unload_area_index][load_area_index] = \
-                #     WalkManage.distance_to_load_area[unload_area_index][load_area_index]
-                # self.cost_to_unload_area[unload_area_index][load_area_index] = \
-                #     WalkManage.distance_to_unload_area[unload_area_index][load_area_index]
+            try:
+                for walk_time in session_postgre.query(WalkTime).all():
+                    load_area_id, unload_area_id = str(walk_time.load_area_id), str(walk_time.unload_area_id)
+                    unload_area_index = unload_area_uuid_to_index_dict[unload_area_id]
+                    load_area_index = load_area_uuid_to_index_dict[load_area_id]
+                    self.cost_to_load_area[unload_area_index][load_area_index], \
+                    self.cost_to_unload_area[unload_area_index][load_area_index] = \
+                        self.path_cost_generate(load_area_id, unload_area_id, False, lane_cost_memory, alpha, beta)
+                    # self.cost_to_load_area[unload_area_index][load_area_index] = \
+                    #     WalkManage.distance_to_load_area[unload_area_index][load_area_index]
+                    # self.cost_to_unload_area[unload_area_index][load_area_index] = \
+                    #     WalkManage.distance_to_unload_area[unload_area_index][load_area_index]
+            except Exception as es:
+                session_postgre.rollback()
+                session_postgre.rollback()
 
             # 读取备停区路网成本
-            for walk_time_park in session_postgre.query(WalkTimePark).all():
-                park_area_index = park_uuid_to_index_dict[str(walk_time_park.park_area_id)]
-                load_area_index = load_area_uuid_to_index_dict[str(walk_time_park.load_area_id)]
-                self.cost_park_to_load_area[park_area_index][load_area_index], _ = \
-                    self.path_cost_generate(str(walk_time_park.load_area_id), str(walk_time_park.park_area_id), True, lane_cost_memory, alpha, beta)
-                # self.cost_park_to_load_area[park_area_index][load_area_index] = \
-                #     WalkManage.distance_park_to_load_area[park_area_index][load_area_index]
+            try:
+                for walk_time_park in session_postgre.query(WalkTimePark).all():
+                    park_area_index = park_uuid_to_index_dict[str(walk_time_park.park_area_id)]
+                    load_area_index = load_area_uuid_to_index_dict[str(walk_time_park.load_area_id)]
+                    self.cost_park_to_load_area[park_area_index][load_area_index], _ = \
+                        self.path_cost_generate(str(walk_time_park.load_area_id), str(walk_time_park.park_area_id), True, lane_cost_memory, alpha, beta)
+                    # self.cost_park_to_load_area[park_area_index][load_area_index] = \
+                    #     WalkManage.distance_park_to_load_area[park_area_index][load_area_index]
+            except Exception as es:
+                session_postgre.rollback()
+                session_postgre.rollback()
 
             logger.info(self.cost_park_to_load_area)
             logger.info(self.distance_park_to_excavator)
@@ -297,6 +326,7 @@ class LaneInfo:
 
         truck_speed_dict = {}
         try:
+            truck_name_to_uuid_dict = get_value("truck_name_to_uuid_dict")
             device_name_set = redis2.keys()
             for item in device_name_set:
                 item = item.decode(encoding='utf-8')
@@ -317,6 +347,8 @@ class LaneInfo:
         :return:
             truck_locate_dict:  (Dict{key:truck_id, value:lane_id}) 矿卡所在路段表
         """
+
+        truck_name_to_uuid_dict = get_value("truck_name_to_uuid_dict")
         self.used_lane_set = []
         # try:
         truck_locate_dict = {}

path_plan/priority_control.py

@@ -31,6 +31,7 @@ class PriorityController:
             walk_weight: 卸载-装载区 路网权重
             park_walk_weight: 备停区-装载区 路网权重
         """
+        park_num = get_value("park_num")
         dynamic_dump_num = get_value("dynamic_dump_num")
         dynamic_excavator_num = get_value("dynamic_excavator_num")
         dynamic_dump_set = get_value("dynamic_dump_set")
@@ -43,7 +44,11 @@ class PriorityController:
         dump_material_priority = np.ones(dynamic_dump_num)
         park_walk_weight = np.ones((park_num, dynamic_excavator_num))
 
-        rule6 = session_mysql.query(DispatchRule).filter_by(id=6).first()
+        try:
+            rule6 = session_mysql.query(DispatchRule).filter_by(id=6).first()
+        except Exception as es:
+            session_postgre.rollback()
+            session_postgre.rollback()
 
         if not rule6.disabled:
             for dump_id in dynamic_dump_set:
@@ -54,7 +59,11 @@ class PriorityController:
                     walk_to_dump_weight[excavator_inedx][dump_index] += dump_priority[dump_index]
             park_walk_weight = park_walk_weight * self.excavator.excavator_priority_coefficient
 
-        rule7 = session_mysql.query(DispatchRule).filter_by(id=7).first()
+        try:
+            rule7 = session_mysql.query(DispatchRule).filter_by(id=7).first()
+        except Exception as es:
+            session_postgre.rollback()
+            session_postgre.rollback()
 
         if not rule7.disabled:
             for dump_id in dynamic_dump_set:
@@ -102,8 +111,12 @@ class PriorityController:
 
         for dump_id in get_value("dynamic_dump_set"):
             for excavator_id in get_value("dynamic_excavator_set"):
-                item = session_mysql.query(Dispatch).filter_by(dump_id=dump_id, exactor_id=excavator_id, isauto=1,
+                try:
+                    item = session_mysql.query(Dispatch).filter_by(dump_id=dump_id, exactor_id=excavator_id, isauto=1,
                                                                isdeleted=0).first()
+                except Exception as es:
+                    session_postgre.rollback()
+                    session_postgre.rollback()
                 if item is not None:
                     dump_index = self.dump.dump_uuid_to_index_dict[dump_id]
                     excavator_index = self.excavator.excavator_uuid_to_index_dict[excavator_id]

settings.py

@@ -67,8 +67,8 @@ def set_log():
 
 
     # timefilehandler = logging.handlers.TimedRotatingFileHandler(log_path + "/dispatch.log", when='M', interval=1, backupCount=60)
-    filehandler = logging.handlers.RotatingFileHandler(log_path + "/dispatch.log", maxBytes=3*1024*1024, backupCount=10)
-    # filehandler = logging.handlers.RotatingFileHandler("./Logs/dispatch.log", maxBytes=3 * 1024 * 1024, backupCount=10)
+    filehandler = logging.handlers.RotatingFileHandler(log_path + "/dispatch.log", maxBytes=3*1024*1024, backupCount=10, encoding="utf-8")
+    # filehandler = logging.handlers.RotatingFileHandler("./Logs/dispatch.log", maxBytes=3 * 1024 * 1024, backupCount=10, encoding="utf-8")
     # 设置后缀名称，跟strftime的格式一样
     filehandler.suffix = "%Y-%m-%d_%H-%M.log"
 

static_data_process.py

@@ -43,6 +43,8 @@ def build_work_area_uuid_index_map():
     except Exception as es:
         logger.error("路网读取")
         logger.error(es)
+        session_postgre.rollback()
+        session_postgre.rollback()
     return (
         load_area_uuid_to_index_dict,
         unload_area_uuid_to_index_dict,
@@ -70,6 +72,8 @@ def build_park_uuid_index_map():
     except Exception as es:
         logger.info("备停区路网读取")
         logger.error(es)
+        session_postgre.rollback()
+        session_postgre.rollback()
 
     return park_uuid_to_index_dict, park_index_to_uuid_dict
 
@@ -90,6 +94,8 @@ def build_truck_uuid_name_map():
             raise Exception("无矿卡设备可用-矿卡设备映射异常")
     except Exception as es:
         logger.warning(es)
+        session_postgre.rollback()
+        session_postgre.rollback()
     return truck_uuid_to_name_dict, truck_name_to_uuid_dict
 
 
@@ -109,6 +115,8 @@ def build_equipment_uuid_name_map():
             raise Exception("无挖机设备可用")
     except Exception as es:
         logger.warning(es)
+        session_postgre.rollback()
+        session_postgre.rollback()
 
 
     try:
@@ -121,6 +129,8 @@ def build_equipment_uuid_name_map():
             raise Exception("无卸载设备可用")
     except Exception as es:
         logger.warning(es)
+        session_postgre.rollback()
+        session_postgre.rollback()
     return excavator_uuid_to_name_dict, dump_uuid_to_name_dict
 
 
@@ -175,6 +185,8 @@ def update_deveices_map(unload_area_uuid_to_index_dict, load_area_uuid_to_index_
     except Exception as es:
         logger.error("卸载区信息异常")
         logger.error(es)
+        session_postgre.rollback()
+        session_postgre.rollback()
 
     logger.info("excavator_index_to_load_area_index_dict")
     logger.info(excavator_index_to_load_area_index_dict)
@@ -241,6 +253,8 @@ def update_total_truck():
     except Exception as es:
         logger.info("矿卡读取")
         logger.error(es)
+        session_postgre.rollback()
+        session_postgre.rollback()
 
     return truck_list
 
@@ -260,6 +274,8 @@ def update_dynamic_truck():
     except Exception as es:
         logger.error(es)
         logger.error("动态调度矿卡读取异常")
+        session_postgre.rollback()
+        session_postgre.rollback()
 
     return set(dynamic_truck_list)
 
@@ -279,11 +295,15 @@ def update_fixdisp_truck():
         rule5 = session_mysql.query(DispatchRule).filter_by(id=5).first().disabled
 
         if not rule5:
-            query = np.array(
-                session_mysql.query(Equipment)
-                .filter_by(device_type=1, isdeleted=0, disabled=1)
-                .all()
-            )
+            try:
+                query = np.array(
+                    session_mysql.query(Equipment)
+                    .filter_by(device_type=1, isdeleted=0, disabled=1)
+                    .all()
+                )
+            except Exception as es:
+                session_postgre.rollback()
+                session_postgre.rollback()
 
             for item in query:
                 fixed_truck_list.append(item.id)
@@ -293,6 +313,8 @@ def update_fixdisp_truck():
     except Exception as es:
         logger.info("派车计划读取")
         logger.error(es)
+        session_postgre.rollback()
+        session_postgre.rollback()
     return set(fixed_truck_list)
 
 
@@ -308,6 +330,8 @@ def update_autodisp_excavator():
             raise Exception("无动态派车计划可用-动态派车挖机/卸载设备集合读取异常")
     except Exception as es:
         logger.warning(es)
+        session_postgre.rollback()
+        session_postgre.rollback()
 
     return set(dynamic_excavator_list)
 
@@ -324,29 +348,43 @@ def update_autodisp_dump():
             raise Exception("无动态派车计划可用-动态派车挖机/卸载设备集合读取异常")
     except Exception as es:
         logger.warning(es)
+        session_postgre.rollback()
+        session_postgre.rollback()
 
     return set(dynamic_dump_list)
 
 
 def update_load_area():
     load_area_list = []
-    for walk_time in session_postgre.query(WalkTime).all():
-        load_area_list.append(walk_time.load_area_id)
+    try:
+        for walk_time in session_postgre.query(WalkTime).all():
+            load_area_list.append(walk_time.load_area_id)
+    except Exception as es:
+        session_postgre.rollback()
+        session_postgre.rollback()
 
     return load_area_list
 
 
 def update_unload_area():
     unload_area_list = []
-    for walk_time in session_postgre.query(WalkTime).all():
-        unload_area_list.append(walk_time.unload_area_id)
+    try:
+        for walk_time in session_postgre.query(WalkTime).all():
+            unload_area_list.append(walk_time.unload_area_id)
+    except Exception as es:
+        session_postgre.rollback()
+        session_postgre.rollback()
     return unload_area_list
 
 
 def update_park_area():
     park_area_list = []
-    for walk_time_park in session_postgre.query(WalkTimePark).all():
-        park_area_list.append(walk_time_park.park_area_id)
+    try:
+        for walk_time_park in session_postgre.query(WalkTimePark).all():
+            park_area_list.append(walk_time_park.park_area_id)
+    except Exception as es:
+        session_postgre.rollback()
+        session_postgre.rollback()
     return park_area_list
 
 # def build_work_area_uuid_index_map():

traffic_flow/traffic_flow_info.py

@@ -192,6 +192,9 @@ class Traffic_para(WalkManage):
 
     # 设置卸载点信息
     def extract_dump_info(self):
+
+        unload_area_index_to_uuid_dict = get_value("unload_area_index_to_uuid_dict")
+
         dynamic_dump_num = get_value("dynamic_dump_num")
         try:
             rule3 = session_mysql.query(DispatchRule).filter_by(id=3).first()