update

rov_server_restart.py

@@ -1,9 +1,10 @@
 import logging
 import time
 import docker
+
+import rov_server_config
 import utils
-from rov_server_update import slb_client_params, slb_id, set_instance_weight_process, \
-    server_health_check
+from rov_server_update import server_health_check
 
 
 def server_restart(slb_client, instance_id, image_name):
@@ -13,7 +14,10 @@ def server_restart(slb_client, instance_id, image_name):
         ip_address = utils.get_ip_address(client=slb_client, instance_id=instance_id)
         logging.info(f"ip address：{instance_id}/{ip_address}")
         # 2. 摘流量
-        set_instance_weight_process(client=slb_client, instance_id_list=[instance_id], weight_list=[(0, 60)])
+        utils.set_instance_weight_process(client=slb_client,
+                                          slb_id=rov_server_config.slb_id,
+                                          instance_id_list=[instance_id],
+                                          weight_list=[(0, 60)])
         logging.info(f"set weight with 0 finished.")
         # 3. 重启容器
         docker_client = docker.DockerClient(base_url=f'tcp://{ip_address}:2375', timeout=60)
@@ -26,7 +30,10 @@ def server_restart(slb_client, instance_id, image_name):
         logging.info(f"health check finished.")
         # 5. 挂流量
         add_weight_list = [(10, 30), (20, 20), (40, 10), (60, 10), (80, 10), (100, 10)]
-        set_instance_weight_process(client=slb_client, instance_id_list=[instance_id], weight_list=add_weight_list)
+        utils.set_instance_weight_process(client=slb_client,
+                                          slb_id=rov_server_config.slb_id,
+                                          instance_id_list=[instance_id],
+                                          weight_list=add_weight_list)
         logging.info(f"server restart finished, instance: {instance_id}/{ip_address}")
     except Exception as e:
         logging.error(f"server restart fail, instance: {instance_id}")
@@ -35,12 +42,12 @@ def server_restart(slb_client, instance_id, image_name):
 
 def main():
     try:
-        slb_client = utils.connect_client(access_key_id=slb_client_params['access_key_id'],
-                                          access_key_secret=slb_client_params['access_key_secret'],
-                                          region_id=slb_client_params['region_id'])
+        slb_client = utils.connect_client(access_key_id=rov_server_config.slb_client_params['access_key_id'],
+                                          access_key_secret=rov_server_config.slb_client_params['access_key_secret'],
+                                          region_id=rov_server_config.slb_client_params['region_id'])
 
         # 1. 获取slb下所有机器
-        online_instance_ids = utils.get_instance_ids(client=slb_client, slb_id=slb_id)
+        online_instance_ids = utils.get_instance_ids(client=slb_client, slb_id=rov_server_config.slb_id)
         online_instance_count = len(online_instance_ids)
         logging.info(f"online instance count: {online_instance_count}.")
         logging.info(f"online instance ids: {online_instance_ids}")

rov_server_update.py

@@ -40,59 +40,28 @@ def server_health_check(client, instance_id):
             time.sleep(10)
 
 
-def set_instance_weight_process(client, instance_id_list, weight_list):
-    """
-    修改服务器的权重值
-    :param client: slb客户端连接
-    :param instance_id_list: instance id list
-    :param weight_list: 权重修改列表 type-list [(weight, sleep_time), ...]
-    :return:
-    """
-    for weight, sleep_time in weight_list:
-        logging.info(f"修改权重中: weight = {weight}")
-        flag = True
-        while flag:
-            try:
-                utils.set_weight_for_instances(client=client,
-                                               slb_id=rov_server_config.slb_id,
-                                               instance_id_list=instance_id_list,
-                                               weight=weight)
-                time.sleep(sleep_time)
-                flag = False
-            except Exception as e:
-                time.sleep(10)
-                continue
-
-
-async def run_server(create_client, slb_client, instance_ids, max_workers):
-    # 1. 发送启动脚本到机器上
-    utils.send_file_to_ecs(client=create_client, instance_id_list=instance_ids, **rov_server_config.start_sh)
-    logging.info(f"send start shell file finished, instances: {instance_ids}")
-    # 2. 启动服务
-    server_start_sh = os.path.join(rov_server_config.start_sh['target_dir'], rov_server_config.start_sh['name'])
-    server_start_commend = f"sh {server_start_sh}"
-    utils.run_command(client=create_client, instance_ids=instance_ids, command=server_start_commend)
-    # 3. 异步探活
-    global health_instances
-    health_instances = []
-    loop = asyncio.get_running_loop()
-    executor = ThreadPoolExecutor(max_workers=max_workers)
-    tasks = [
-        loop.run_in_executor(executor, server_health_check, *args) for args in
-        [(slb_client, instance_id) for instance_id in instance_ids]
-    ]
-    await asyncio.wait(tasks)
-    logging.info(f"health instances count: {len(health_instances)}, {health_instances}")
-    # 4. 挂载流量
-    if len(health_instances) == len(instance_ids):
-        # 所有机器探活成功
-        time.sleep(60)
-        add_weight_list = [(10, 30), (20, 20), (40, 10), (60, 10), (80, 10), (100, 10)]
-        set_instance_weight_process(client=slb_client, instance_id_list=instance_ids, weight_list=add_weight_list)
-        logging.info(f"add weight instances count: {len(health_instances)}")
-    else:
-        logging.info(f"instances count: {len(instance_ids)},\nhealth instances count: {len(health_instances)}")
-        sys.exit()
+# def set_instance_weight_process(client, instance_id_list, weight_list):
+#     """
+#     修改服务器的权重值
+#     :param client: slb客户端连接
+#     :param instance_id_list: instance id list
+#     :param weight_list: 权重修改列表 type-list [(weight, sleep_time), ...]
+#     :return:
+#     """
+#     for weight, sleep_time in weight_list:
+#         logging.info(f"修改权重中: weight = {weight}")
+#         flag = True
+#         while flag:
+#             try:
+#                 utils.set_weight_for_instances(client=client,
+#                                                slb_id=rov_server_config.slb_id,
+#                                                instance_id_list=instance_id_list,
+#                                                weight=weight)
+#                 time.sleep(sleep_time)
+#                 flag = False
+#             except Exception as e:
+#                 time.sleep(10)
+#                 continue
 
 
 async def ess_instance(create_client, slb_client, ess_count, max_workers, version):
@@ -138,7 +107,10 @@ async def ess_instance(create_client, slb_client, ess_count, max_workers, versio
         utils.add_backend_servers(client=slb_client, slb_id=rov_server_config.slb_id, instances=health_instances)
         health_instance_ids = [instance_id for instance_id, _ in health_instances]
         add_weight_list = [(10, 30), (20, 20), (40, 10), (60, 10), (80, 10), (100, 10)]
-        set_instance_weight_process(client=slb_client, instance_id_list=health_instance_ids, weight_list=add_weight_list)
+        utils.set_instance_weight_process(client=slb_client,
+                                          slb_id=rov_server_config.slb_id,
+                                          instance_id_list=health_instance_ids,
+                                          weight_list=add_weight_list)
         global ess_instances
         ess_instances.extend(health_instance_ids)
         logging.info(f"ess count: {ess_count}, "
@@ -211,7 +183,10 @@ async def update_instance(create_client, slb_client, instance_ids, max_workers,
     for instance_id_list in instance_ids_group:
         logging.info(f"update instances: {instance_id_list}")
         # 1. 摘流量
-        set_instance_weight_process(client=slb_client, instance_id_list=instance_id_list, weight_list=[(0, 60)])
+        utils.set_instance_weight_process(client=slb_client,
+                                          slb_id=rov_server_config.slb_id,
+                                          instance_id_list=instance_id_list,
+                                          weight_list=[(0, 60)])
         logging.info(f"set weight with 0 finished, instances: {instance_id_list}")
         # 2. 异步移除旧容器并删除旧镜像
         global remove_container_instances
@@ -255,8 +230,10 @@ async def update_instance(create_client, slb_client, instance_ids, max_workers,
             utils.add_backend_servers(client=slb_client, slb_id=rov_server_config.slb_id, instances=health_instances)
             health_instance_ids = [instance_id for instance_id, _ in health_instances]
             add_weight_list = [(10, 30), (20, 20), (40, 10), (60, 10), (80, 10), (100, 10)]
-            set_instance_weight_process(client=slb_client, instance_id_list=health_instance_ids,
-                                        weight_list=add_weight_list)
+            utils.set_instance_weight_process(client=slb_client,
+                                              slb_id=rov_server_config.slb_id,
+                                              instance_id_list=health_instance_ids,
+                                              weight_list=add_weight_list)
             logging.info(f"finished instances: {health_instances}, count: {len(health_instances)}")
             update_finished_count += len(health_instances)
             logging.info(f"update finished: {update_finished_count}/{len(instance_ids)}")
@@ -274,7 +251,10 @@ def remove_instances(create_client, slb_client, instance_ids):
     :return: None
     """
     # 1. 摘流量
-    set_instance_weight_process(client=slb_client, instance_id_list=instance_ids, weight_list=[(0, 60)])
+    utils.set_instance_weight_process(client=slb_client,
+                                      slb_id=rov_server_config.slb_id,
+                                      instance_id_list=instance_ids,
+                                      weight_list=[(0, 60)])
     logging.info(f"set weight = 0 finished, instances: {instance_ids}")
     time.sleep(10)
     # 2. 停止机器

utils.py

@@ -339,7 +339,7 @@ def set_instance_weight_process(client, slb_id, instance_id_list, weight_list):
 
 def add_backend_servers(client, slb_id, instances):
     """
-    服务器挂载到负载均衡
+    服务器挂载到负载均衡(必须是状态为运行中的后端服务器才可以加入负载均衡实例，每次调用最多可添加20个后端服务器)
     :param client:
     :param slb_id:
     :param instances: 实例列表 [(instance_id, ip), ...]
@@ -353,4 +353,52 @@ def add_backend_servers(client, slb_id, instances):
         for instance_id, ip_address in instances]
     request.set_BackendServers(backend_servers)
     response = client.do_action_with_exception(request)
-    return response
+    return response
+
+
+def set_instance_weight_process_with_slbs(client, slb_id_list, instance_id_list, weight_list):
+    """
+    修改服务器的权重值
+    :param client: slb客户端连接
+    :param slb_list: slb id list
+    :param instance_id_list: instance id list
+    :param weight_list: 权重修改列表 type-list [(weight, sleep_time), ...]
+    :return:
+    """
+    for weight, sleep_time in weight_list:
+        logging.info(f"修改权重中: weight = {weight}")
+        for slb_id in slb_id_list:
+            flag = True
+            while flag:
+                try:
+                    set_weight_for_instances(client=client, slb_id=slb_id, instance_id_list=instance_id_list, weight=weight)
+                    time.sleep(sleep_time)
+                    logging.info(f"slb: {slb_id} finished！")
+                    flag = False
+                except Exception as e:
+                    time.sleep(10)
+                    continue
+
+
+def add_backend_servers_with_slbs(client, slb_id_list, instances):
+    """
+    服务器挂载到负载均衡(必须是状态为运行中的后端服务器才可以加入负载均衡实例，每次调用最多可添加20个后端服务器)
+    :param client:
+    :param slb_id_list:
+    :param instances: 实例列表 [(instance_id, ip), ...]
+    :return:
+    """
+    try:
+        for slb_id in slb_id_list:
+            request = AddBackendServersRequest()
+            request.set_accept_format('json')
+            request.set_LoadBalancerId(slb_id)
+            backend_servers = [
+                {"ServerId": instance_id, "Weight": "0", "Type": "ecs", "ServerIp": ip_address}
+                for instance_id, ip_address in instances]
+            request.set_BackendServers(backend_servers)
+            response = client.do_action_with_exception(request)
+            logging.info(f"slb: {slb_id} add backend servers finished!")
+    except Exception as e:
+        logging.error(e)
+        sys.exit()