> 下面指令碼主要根據網路WSN最初OGG檢測指令碼修改而來，增加了推送釘釘以及判斷故障等情況。

主要功能如下：
1. 監測ssh是否能正常連線，無法連線，推送告警。
2. 監測OGG鏈路延遲，程式狀態，異常或延遲達到閾值則推送訊息。
3. 可以巡檢Linux、AIX、Solaris平臺OGG，並將異常鏈路推送釘釘機器人訊息。

如需使用，需要根據自己環境修改下面部分即可：
1. hostlist中資訊，如果有多個主機需要監測，則複製多個花括號中部分，逗號隔開即可。
4. 釘釘webhook地址，根據自己申請釘釘機器人webhook地址修改即可。
5. 釘釘機器人金鑰，根據釘釘機器人配置介面啟用金鑰填寫即可。 
6. 指令碼自身監測以及多久監測一次，根據自己需要，修改second變數以及exec_cnt即可。
7. 如果是內網環境，需要取消send_message函式中網際網路代理設定，填寫自己內網代理伺服器地址。

```python
#!/usr/bin/env python
# -*-coding: utf-8 -*-
# @Time:2020/7/13 9:47
# @Author: WSN
# @Time:2022/06/07 17:45
# @Modified CZH

import paramiko
import re
import datetime
import time
import os
import hmac
import hashlib
import urllib
import base64
import requests
import json

hostlist=[
{'host': 'IP地址', 'port': 'ssh埠', 'user': 'ogg作業系統使用者', 'pwd': 'xxxx', 'oggdir': 'ogg安裝目錄','orahome': 'oracle_home目錄'}
]

# 釘釘傳送函式，輸入markdown格式訊息文字即可傳送
def send_message(send_msg,warn_type):
    ### 釘釘配置 begin ###                                                                                                                              
    # 如果是內網，需要有網際網路代理配置                                                                                                                  
    # proxies = {'http':'http://IP:PORT','https':'http://IP:PORT'}                                                                                      
    # os.environ["https_proxy"] = "http://IP:PORT"                                                                                            
    webhook="釘釘機器人webhook地址"                        
    timestamp = str(round(time.time() * 1000))                                                                                                          
    secret = '釘釘機器人加密金鑰'                                                                      
    secret_enc = secret.encode('utf-8')                                                                                                                 
    string_to_sign = '{}\n{}'.format(timestamp, secret)                                                                                                 
    string_to_sign_enc = string_to_sign.encode('utf-8')                                                                                                 
    hmac_code = hmac.new(secret_enc, string_to_sign_enc, digestmod=hashlib.sha256).digest()                                                             
    sign = urllib.parse.quote_plus(base64.b64encode(hmac_code))                                                                                         
    webhook = webhook + '×tamp=' + timestamp + '&sign=' + sign
    # timestamp 與系統當前時間戳如果相差1小時以上，則認為是非法的請求，所以需要注意傳送訊息伺服器時間不能與標準時間相差超過一小時                                                                         
    headers = {'Content-Type': 'application/json'}                                                                                                      
    user = "all"                                                                                                                                        
    ### 釘釘配置 end ### 
    data={                                                                                                                                          
        "msgtype": "markdown",                                                                                                                      
        "markdown": {                                                                                                                               
            "title": "資料庫告警",                                                                                                                  
            "text": f"# <font face="\"華雲彩繪\"" color="\"#FF0000\"" size="\"10\"">{warn_type}</font> \n " + send_msg                                      
        },                                                                                                                                          
        "at": {                                                                                                                                     
            "atMobiles": [                                                                                                                          
                user                                                                                                                                
            ],                                                                                                                                      
            "isAtAll": False                                                                                                                        
        }                                                                                                                                           
    }                                                                                                                                               
    #print(data)                                                                                                                                    
    x=requests.post(url=webhook,data=json.dumps(data),headers=headers)                                                                              
    # 列印傳送釘釘結果                                                                                                                              
    print('釘釘推送結果為： ' + str(x.json()) + '\n')

def curtime():
    timenow = str(datetime.datetime.now()) + ' '
    return timenow

# 定義一個休眠迴圈，定期執行指令碼
def sleeptime(hour, min, sec):
    return hour * 3600 + min * 60 + sec

class SshOgg:
    def __init__(self, host, port, username, pwd):
        self.host = host
        self.port = port
        self.username = username
        self.pwd = pwd
        self.orahome = orahome
        self.ssh = paramiko.SSHClient()
        self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        try:
            self.ssh.connect(self.host, self.port, self.username, self.pwd, timeout=5)
            self.sshinvalid = False
            print(self.sshinvalid)
        except:
            self.sshinvalid = True
            print(self.sshinvalid)

def check_ogg_status(self,orahome,oggdir):
        if self.sshinvalid:
            send_msg = ('**告警時間：** ' + curtime()  + ' \\\n **告警主機：** ' + self.host )
            send_message(send_msg,warn_type='主機SSH無法連線')
        else:
            # 考慮AIX與Linux不同平臺library path不同，所以一起設定，防止需要多判斷處理不同平臺
            cmd = 'export LD_LIBRARY_PATH=%s/lib:%s && export LD_LIBRARY_PATH=%s/lib:%s && echo "info all" |%s/ggsci' % (orahome,oggdir,orahome,oggdir,oggdir)
            # print(cmd)
            stdin, stdout, stderr = self.ssh.exec_command(cmd)
            # print(stdout.readlines)
            for i in stderr.readlines():
                send_msg = ('**告警時間：** ' + curtime()  + ' \\\n **告警主機：** ' + self.host + ' \\\n **告警內容：** ' + i )
                send_message(send_msg,warn_type='無法檢測OGG')
                print(i)
            # print(stdout.readlines)
            for i in stdout.readlines():
                # 計數程式和，不為0再進行處理
                v_proc_cnt = i.count('MANAGER')
                v_proc_cnt = v_proc_cnt + i.count('EXTRACT')
                v_proc_cnt = v_proc_cnt + i.count('REPLICAT')
                while v_proc_cnt >= 1:
                    # 確定取到程式行再進行切片，方便判斷取值
                    v_i = i.split()
                    print(v_i)
                    # 將程式與狀態賦予變數，用於後面判斷
                    if len(v_i) == 2:
                        v_proc_type = v_i[0]
                        v_proc_status = v_i[1]
                    elif len(v_i) >= 3:
                        # 程式型別
                        v_proc_type = v_i[0]
                        v_proc_status = v_i[1]
                        # 程式具體名稱
                        v_proc_name = v_i[2]
                        # lag at chkpt，讀取trail檢查點延遲
                        v_lac = str(v_i[3]).split(':')
                        if len(v_lac) == 1:
                            lag_at_ckpt = v_lac[0]
                        else:
                            lag_at_ckpt = int(v_lac[0])*3600 + int(v_lac[1])*60 + int(v_lac[2])
                            print(lag_at_ckpt)
                        print(v_lac)
                        # 切片time since ckpt，然後計算延遲秒數
                        v_tsc = str(v_i[4]).split(':')
                        print(v_tsc)
                        time_since_ckpt = int(v_tsc[0])*3600 + int(v_tsc[1])*60 + int(v_tsc[2])
                        print(time_since_ckpt)
    
                    if v_proc_type == 'MANAGER':
                        print(curtime())
                        print(self.host)
                        print(v_proc_type)
                        print(v_proc_status)
                        send_msg = ('**告警時間：** ' + curtime() + ' \\\n **告警主機：** ' + self.host + ' \\\n **OGG程式：** ' + 
                        v_proc_type + ' \\\n **當前狀態 ：** ' + v_proc_status)
                    else:
                        send_msg = ('**告警時間：** ' + curtime() + ' \\\n **告警主機：** ' + self.host + ' \\\n **程式型別：** ' + 
                        v_proc_type + ' \\\n **程式名稱 ：**  ' + v_proc_name + ' \\\n **當前狀態 ：** ' + v_proc_status + ' \\\n **Lag at Chkpt：** ' + str(lag_at_ckpt) + 's' + ' \\\n **Time Since Chkpt：** ' + str(time_since_ckpt) + 's')
                    """
                    1.
    
                    """
                    if v_proc_type == 'MANAGER' and v_proc_status == 'RUNING':
                        send_message(send_msg,warn_type='OGG MGR正常')
                        time.sleep(3)
                    elif v_proc_type == 'MANAGER' and  v_proc_status != 'RUNNING':
                        send_message(send_msg,warn_type='OGG MGR異常')
                        time.sleep(3)
                    # 程式lag at chkpt如果狀態為unknown則，len(v_lac)為1
                    elif len(v_lac) == 1:
                        send_message(send_msg,warn_type='OGG狀態異常')
                        time.sleep(3)
                    elif len(v_lac) > 1 and v_proc_status == 'ABENDED':
                        send_message(send_msg,warn_type='OGG故障')
                        time.sleep(3)
                    elif len(v_lac) > 1 and v_proc_status == 'STOPPED':
                        send_message(send_msg,warn_type='OGG停止')
                        time.sleep(3)      
                    elif len(v_lac) > 1 and lag_at_ckpt >= 1800:
                        send_message(send_msg,warn_type='OGG佇列讀延遲')
                        time.sleep(3)
                    elif time_since_ckpt >= 1800:
                        send_message(send_msg,warn_type='OGG應用延遲')
                        time.sleep(3)
                    elif v_proc_type == 'EXTRACT' and v_proc_status != 'RUNNING':
                        send_message(send_msg,warn_type='OGG EXTRACT異常')
                        time.sleep(3)
                    elif v_proc_type == 'REPLICAT' and v_proc_status != 'RUNNING':
                        send_message(send_msg,warn_type='OGG應用異常')
                        time.sleep(3)
                    else:
                        send_message(send_msg,warn_type='其他情況')
                        time.sleep(3)
                    # while只執行一次即重新獲取下一行程式資訊判斷，避免陷入死迴圈
                    break

def closed(self):
        self.ssh.close()

# 定時格式為時，分，秒，間隔5分鐘執行一次
second = sleeptime(0, 0, 10)
# 用於監測指令碼本身，定時傳送指令碼執行郵件，防止指令碼自身異常
exec_cnt = 0
while 1==1 :
    for con_info in hostlist:
        host = con_info['host']
        port = con_info['port']
        username = con_info['user']
        pwd = con_info['pwd']
        oggdir = con_info['oggdir']
        orahome = con_info['orahome']
        ssh = SshOgg(host, port, username, pwd)
        print('\n------------%s上ogg程式執行狀態資訊------------' % host)
        print(curtime() + '\n')
        ssh.check_ogg_status(orahome,oggdir)
        ssh.closed()
    print(curtime())
    exec_cnt = exec_cnt + 1
    print('Current execute count is :' + str(exec_cnt) + '\n')
    if exec_cnt == 10:
        send_message('This scripts is running!',warn_type='推送服務監測')
        exec_cnt = 0
    time.sleep(second)
```

Python巡檢OGG並推送釘釘訊息

相關文章