编写一个脚本监听sql的运行状态并联动另一台服务器上的服务重启

A服务器上部署sqlserver。B服务器上（linux）部署了一个服务去实时查询A服务器上的视图并进行后续处理工作。
当A服务器上进行例维或者重启后，B服务器上的程序无法自动再次连接SQL。
想完成功能 去监听A服务器上上SQL的状态，发现A服务器上的SQL重启恢复正常后，等待1分钟后自动重启B服务器上的服务

该回答引用于gpt与OKX安生共同编写：
  • 该回答引用于gpt与OKX安生共同编写：

可以编写一个脚本来监听 A 服务器上 SQL Server 的状态，并在 SQL 服务重启后自动重启 B 服务器上的服务。下面是一个示例脚本的实现：

#!/bin/bash

# 设置 SQL Server 连接信息
SQL_HOST="A服务器IP"
SQL_PORT=1433
SQL_USER="SQL用户名"
SQL_PASSWORD="SQL密码"
SQL_DATABASE="数据库名"

# 设置需要监控的服务名称
SERVICE_NAME="服务名称"

# 检查服务是否启动
check_service() {
    if systemctl is-active $SERVICE_NAME >/dev/null; then
        echo "Service $SERVICE_NAME is running."
    else
        echo "Service $SERVICE_NAME is not running."
        systemctl start $SERVICE_NAME
        echo "Starting service $SERVICE_NAME..."
    fi
}

# 检查 SQL Server 是否可连接
check_sql() {
    if /opt/mssql-tools/bin/sqlcmd -S $SQL_HOST,$SQL_PORT -U $SQL_USER -P $SQL_PASSWORD -d $SQL_DATABASE -Q "SELECT @@VERSION" &>/dev/null; then
        echo "SQL Server is running."
    else
        echo "SQL Server is not running. Restarting service $SERVICE_NAME in 1 minute..."
        sleep 60
        systemctl restart $SERVICE_NAME
        check_service
    fi
}

# 主循环
while true; do
    check_sql
    sleep 10
done

这个脚本会每隔 10 秒钟检查一次 SQL Server 和服务状态。如果发现 SQL Server 不可连接，则会等待 1 分钟后自动重启服务。如果服务已经在运行，则不会进行任何操作。

你可以将这个脚本保存为一个可执行文件，然后在 B 服务器上使用 systemd 等服务管理工具来自动启动和管理。

参考GPT和自己的思路：首先，要实现这个功能，你需要编写一个脚本来监听A服务器上SQL的运行状态，并自动重启B服务器上的服务。你可以通过以下步骤来实现：

  1. 在A服务器上配置SQL服务的启动和停止脚本，并记录SQL服务的状态，如运行中、停止等。

  2. 在B服务器上编写一个程序，实时查询A服务器上的状态（可以使用视图），并判断SQL服务的状态是否正常。

  3. 编写一个定时任务，每隔一段时间检查一次SQL服务的状态。

  4. 当检查到SQL服务状态发生变化（如从运行中变为停止），则等待一分钟后，启动B服务器上的服务。

  5. 如果SQL服务状态为正常，则继续等待下一次定时任务执行。

需要注意的是，在编写脚本过程中需要考虑到安全性和稳定性，确保脚本能够正确地运行而不影响已有的服务。同时，还可以将日志记录到文件中，以便及时发现和处理问题。

您可以使用Python编写一个脚本来监听SQL Server的状态，并在SQL Server重新启动后自动重启B服务器上的服务。以下是一个示例脚本，它使用pyodbc库连接到SQL Server并检查连接是否处于活动状态。如果连接断开，脚本将等待1分钟，然后尝试重新连接。如果重新连接成功，脚本将使用paramiko库连接到B服务器并重启服务。


```python
import pyodbc
import paramiko
import time

# Set the connection parameters for SQL Server
server = 'your_server_name'
database = 'your_database_name'
username = 'your_username'
password = 'your_password'

# Set the connection parameters for the remote server
hostname = 'your_remote_server_hostname'
port = 22
username = 'your_remote_server_username'
password = 'your_remote_server_password'
command = 'sudo service your_service_name restart'

# Connect to SQL Server
cnxn = pyodbc.connect('DRIVER={SQL Server};SERVER='+server+';DATABASE='+database+';UID='+username+';PWD='+ password)

# Check if the connection is active
while True:
    try:
        cnxn.cursor()
    except pyodbc.Error:
        # Wait for 1 minute before trying to reconnect
        time.sleep(60)
        try:
            cnxn = pyodbc.connect('DRIVER={SQL Server};SERVER='+server+';DATABASE='+database+';UID='+username+';PWD='+ password)
        except pyodbc.Error:
            continue
    else:
        break

# Connect to the remote server and restart the service
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(hostname, port, username, password)
stdin, stdout, stderr = ssh.exec_command(command)
ssh.close()



```在这个例子中，您需要将your_server_name、your_database_name、your_username和your_password替换为SQL Server的连接参数，将your_remote_server_hostname、your_remote_server_username、your_remote_server_password和your_service_name替换为远程服务器的连接参数和要重启的服务的名称。

建议先考虑定立制度，竟然能重启数据库不通知应用，而且应用还是不能自动重连需要重启的。
可以考虑采用中间件实现数据库自动重连，数据库重启，应用自动恢复。
自己写脚本shell描述，无线循环，没每10秒链接一次数据库，查询select getdate ()，如果链接失败，设置预重启应用标志y=y+1,x=0,持续检测，当y>0时间，查询成功，x=x+1,当x=6时间，执行重启b服务命令，标志.x和y置0。

以下答案由GPT-3.5大模型与博主波罗歌共同编写：
实现该功能，可以采用以下步骤：

1.在A服务器上写一个脚本，通过查询SQL Server的运行状态，当发现SQL Server状态异常时，就向B服务器上发送一个信号，让其重启服务。

2.在B服务器上写另一个脚本，用于监控A服务器传来的信号，并执行相应的重启服务操作。

下面给出两个脚本示例：

A服务器脚本：

import pymssql
import os
import time
import socket

#数据库连接信息
server_ip = "localhost"已黑化的小白 username = "sa"已黑化的小白 password = "your_password"已黑化的小白 database = "master"已黑化的小白 
#发送信号的函数
def send_signal():
    #需要先确认B服务器的IP地址
    B_ip = "B_server_ip"已黑化的小白     #打开B服务器上的一个端口
    #将下一行代码中的your_port_number替换成一个未被占用的端口号
    port = your_port_number
    s = socket.socket()
    s.connect((B_ip, port))
    s.sendall(b'signal')
    s.close()

#检查SQL Server的运行状态
def check_sql_status():
    conn = pymssql.connect(server=server_ip, user=username, password=password, database=database)
    cursor = conn.cursor()
    cursor.execute("EXEC xp_cmdshell 'net start | findstr MSSQL$'") #检查SQL Server的状态
    result = cursor.fetchall()
    conn.commit()
    conn.close()
    #如果状态异常，则发送信号
    if result == []:
        send_signal()

if __name__ == '__main__':
    while True:
        check_sql_status()
        time.sleep(30) #指定检查时间间隔

B服务器脚本：

import socket
import subprocess
import time

#启动服务的函数
def start_service():
    #将下一行代码中的your_service_name替换成你需要重启的服务名称
    service_name = 'your_service_name'
    subprocess.call(['systemctl', 'start', service_name])

#接收信号的函数
def receive_signal():
    #需要先确认A服务器的IP地址
    A_ip = "A_server_ip"已黑化的小白     #将下一行代码中的your_port_number替换成A服务器上开放的端口号
    port = your_port_number
    s = socket.socket()
    s.bind((A_ip, port))
    s.listen(1)
    while True:
        conn, addr = s.accept()
        signal = conn.recv(1024)
        if signal == b'signal':
            conn.close()
            start_service()
            break

if __name__ == '__main__':
    while True:
        try:
            receive_signal()
        except Exception as e:
            print(e)
            time.sleep(60) #指定重启间隔时间

需要注意的是，在程序中有一些需要替换的参数，具体请查看注释。同时，由于在B服务器上需要指定一些服务相关信息，你需要先确认你的B服务器上的服务名称及启动命令等相关信息。

另外，由于涉及到机器间通信，需要保证两台服务器能互相访问，并没有任何网络障碍。
如果我的回答解决了您的问题，请采纳！

为了实现监听SQL的运行状态并联动另一台服务器上的服务重启，我们可以采用以下步骤：
1. 在A服务器上编写一个脚本，用于监听SQL的运行状态。该脚本可以通过查询系统表或者使用SQL Server Management Studio的活动监视器来实现。当SQL Server出现异常或者停止运行时，该脚本会自动触发一个事件。
2. 在B服务器上编写一个脚本，用于检测A服务器上的SQL Server是否可用。该脚本可以通过连接A服务器上的SQL Server并执行一个简单的查询来实现。如果查询成功，则说明SQL Server可用；否则，说明SQL Server不可用。
3. 在B服务器上编写一个脚本，用于重启B服务器上的服务。该脚本可以使用Linux系统的服务管理工具（如systemctl）来实现。当B服务器上的服务出现异常或者停止运行时，该脚本会自动触发一个事件。
4. 在B服务器上编写一个脚本，用于自动连接A服务器上的SQL Server。该脚本可以使用Python或者其他编程语言来实现。当B服务器上的服务重启后，该脚本会自动连接A服务器上的SQL Server，并执行必要的操作。
5. 将以上脚本整合到一个统一的脚本中，并使用Linux系统的定时任务工具（如cron）来定期执行。该脚本可以每隔一段时间检测A服务器上的SQL Server是否可用，如果不可用则自动重启B服务器上的服务，并自动连接A服务器上的SQL Server。
通过以上步骤，我们可以实现监听SQL的运行状态并联动另一台服务器上的服务重启的功能。这样，当A服务器上的SQL Server出现异常或者停止运行时，B服务器上的服务会自动重启，并自动连接A服务器上的SQL Server，保证系统的稳定性和可用性。

可以通过编写一个 Bash 脚本，在 B 服务器上运行，用于监听 A 服务器上 SQL Server 的状态，并在 SQL Server 重启后等待一段时间后重启 B 服务器上的服务。具体的实现步骤如下：
1.在 B 服务器上安装 mssql-cli 工具，用于连接 A 服务器上的 SQL Server：

sudo apt-get update
sudo apt-get install mssql-cli
  1. 编写一个无限循环的脚本，用于检测 SQL Server 是否可用。可以使用 mssql-cli 工具连接 SQL Server，如果连接失败，则说明 SQL Server 不可用。脚本中的代码如下：
#!/bin/bash

while true; do
    mssql-cli -S A_SERVER_ADDRESS -U USERNAME -P PASSWORD -Q "SELECT 1" >/dev/null 2>&1
    if [ $? -ne 0 ]; then
        echo "SQL Server is not available"
        sleep 10
    else
        echo "SQL Server is available"
        break
    fi
done

其中，A_SERVER_ADDRESS、USERNAME 和 PASSWORD 分别是 A 服务器的地址、SQL Server 的登录名和密码。脚本中的 sleep 10 表示每隔 10 秒钟检测一次 SQL Server 的状态，可以根据实际情况调整这个值。
3. 当 SQL Server 重启后，等待一段时间后重启 B 服务器上的服务。可以在脚本中添加一个延时的功能，然后再执行重启服务的命令。脚本中的代码如下：

#!/bin/bash

while true; do
    mssql-cli -S A_SERVER_ADDRESS -U USERNAME -P PASSWORD -Q "SELECT 1" >/dev/null 2>&1
    if [ $? -ne 0 ]; then
        echo "SQL Server is not available"
        sleep 10
    else
        echo "SQL Server is available"
        sleep 60
        sudo systemctl restart SERVICE_NAME
        break
    fi
done

其中，SERVICE_NAME 表示需要重启的服务的名称。脚本中的 sleep 60 表示等待 60 秒钟后再重启服务，可以根据实际情况调整这个值。
4.将脚本保存为一个文件，并添加执行权限：

chmod +x script.sh
  1. 启动脚本，可以使用 nohup 命令后台运行：
nohup ./script.sh &

这样，当 A 服务器上的 SQL Server 重启后，B 服务器上的服务就会在一段时间后自动重启。注意，在脚本中需要填写正确的 A 服务器地址、登录名、密码和服务名称，并根据实际情况调整脚本中的延时时间。