storwize_get_state.py

#!/bin/python3
# -*- coding: utf-8 -*-

import os
import time
import argparse
import sys
import json
import subprocess
import paramiko
import logging
import logging.handlers
import csv
import re

# Create log-object
LOG_FILENAME = "/tmp/storwize_state.log"
# sys.argv[5] contain this string "--storage_name=<storage_name_in_zabbix>". List slicing delete this part "--storage_name="
STORAGE_NAME = sys.argv[5][15:]
storwize_logger = logging.getLogger("storwize_logger")
storwize_logger.setLevel(logging.INFO)

# Set handler
storwize_handler = logging.handlers.RotatingFileHandler(LOG_FILENAME, maxBytes=(1024**2)*10, backupCount=5)
storwize_formatter = logging.Formatter('{0} - %(asctime)s - %(name)s - %(levelname)s - %(message)s'.format(STORAGE_NAME))

# Set formatter for handler
storwize_handler.setFormatter(storwize_formatter)

# Add handler to log-object
storwize_logger.addHandler(storwize_handler)

def storwize_connect(storwize_user, storwize_password, storwize_ip, storwize_port):
    try:
        ssh_client = paramiko.SSHClient()
        ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        ssh_client.connect(hostname=storwize_ip, username=storwize_user, password=storwize_password, port=22)
        storwize_logger.info("Connection Established Successfully")
        return ssh_client
    except Exception as oops:
        storwize_logger.info("Connection Close Error Occurs: {0}".format(oops))
        sys.exit("1000")

def storwize_logout(ssh_client):
    try:
        ssh_client.close()
        storwize_logger.info("Connection Closed Successfully")
    except Exception as oops:
        storwize_logger.info("Connection Close    Error Occurs: {0}".format(oops))
        sys.exit("1000")

def convert_to_zabbix_json(data):
    output = json.dumps({"data": data}, indent = None, separators = (',',': '))
    return output

def convert_text_to_numeric(value):
    if value == 'online':
        numericValue = 0
    elif value == 'offline':
        numericValue = 1
    elif value == 'degraded':
        numericValue = 2
    elif value == 'active':
        numericValue = 3
    elif value == 'inactive_configured':
        numericValue = 4
    elif value == 'inactive_unconfigured':
        numericValue = 5
    elif value == 'offline_unconfigured':
        numericValue = 6
    elif value == 'excluded':
        numericValue = 7
    elif value == 'on':
        numericValue = 8
    elif value == 'off':
        numericValue = 9
    elif value == 'slow_flashing':
        numericValue = 10
    elif value == 'degraded_paths':
        numericValue = 11
    elif value == 'degraded_ports':
        numericValue = 12
    else:
        numericValue = 100

    return numericValue

def advanced_info_of_resource(resource, needed_attributes, storwize_connection, *id_of_resource):

    """ needed_attributes - list of parameters, that we wont to get
            id_of_resource - list of additional parameters, that uniquely determine resource.
            Example: for PSU - first element of list is enclosure_id, secondary element of list is PSU_id"""

    if resource == 'lsenclosure':
        stdin, stdout, stderr = storwize_connection.exec_command('svcinfo {0} {1}'.format(resource, id_of_resource[0]))
    elif resource == 'lsenclosurepsu':
        stdin, stdout, stderr = storwize_connection.exec_command('svcinfo {0} -psu {1} {2}'.format(resource, id_of_resource[1], id_of_resource[0]))

    if len(stderr.read()) > 0:
        storwize_logger.info("Error Occurs in advanced info of enclosure - {0}".format(stderr.read()))
        storwize_logout(storwize_connection)
        sys.exit("1100")
    else:
        attributes_of_resource = stdout.read() # Получили расширенные атрибуты в виде строки (variable contain advanced attributes in string)
        dict_of_attributes = {} # Здесь будут храниться расширенные атрибуты ресурса в формате ключ-значение (will contain advanced attributes in key-value)
        try:
            for attribute in attributes_of_resource.decode().split('\n'): # Разделил строку и получили список из расшренные атрибутов
                if len(attribute) > 0:
                    temp = attribute.split(' ')
                    dict_of_attributes[temp[0]] = temp[1]
        except Exception as oops:
            storwize_logger.error("Error occures in function advanced_info_of_resource - {0}".format(oops))
            storwize_logout(storwize_connection)
            sys.exit("1100")

    # Создаем словарь из необходимых нам свойств ресурса (create dictionary that contain properies of resource)
    result = {}
    for each_value in needed_attributes:
        result[each_value] = dict_of_attributes[each_value]

    return result

def convert_capacity_to_bytes(capacity_in_string):
    """ Конвертирует значение, которое отдает СХД в виде строки, в байты
    Convert value, from string to byte, that get from storage device
        """

    convert_to_bytes = {'TB':1024**4, 'GB':1024**3, 'MB':1024**2, 'KB':1024}
    try:
        if capacity_in_string == '0':
            converted_capacity = '0'
        else:
            list_of_capacity = re.search('([\d\.]+)([\D]+)',capacity_in_string) # Ищем по регулярному выражению и находим две группы совпадения
            converted_capacity = float(str(list_of_capacity.group(1))) * convert_to_bytes[list_of_capacity.group(2)]
        return int(converted_capacity) # Конвертация в целые числа, потому что для float в заббиксе есть ограничение (convert to type ineger)
    except Exception as oops:
        storwize_logger.error("Error occurs in converting capactity_in_string to capactiy_in_bytes. Error: {0}".format(oops))

def send_data_to_zabbix(zabbix_data, storage_name):
    sender_command = "/usr/bin/zabbix_sender"
    config_path = "/etc/zabbix/zabbix_agentd.conf"
    time_of_create_file = int(time.time())
    temp_file = "/tmp/{0}_{1}.tmp".format(storage_name, time_of_create_file)

    with open(temp_file, "w") as f:
        f.write("")
        f.write("\n".join(zabbix_data))

    send_code = subprocess.call([sender_command, "-vv", "-c", config_path, "-s", storage_name, "-T", "-i", temp_file], stdout = subprocess.PIPE, stderr = subprocess.PIPE)
    os.remove(temp_file)
    return send_code

def discovering_resources(storwize_user, storwize_password, storwize_ip, storwize_port, storage_name, list_resources):
    storwize_connection = storwize_connect(storwize_user, storwize_password, storwize_ip, storwize_port)

    xer = []
    try:
        for resource in list_resources:
            stdin, stdout, stderr = storwize_connection.exec_command('svcinfo {0} -delim :'.format(resource))

            if len(stderr.read()) > 0: # Если случились ошибки, запиши их в лог и выйди из скрипта (If errors occur, than write them to log and correctyl end of ssh-session)
                storwize_logger.info("Error Occurs in SSH Command - {0}".format(stderr.read()))
                storwize_logout(storwize_connection)
                sys.exit("1100")
            else:
                resource_in_csv = csv.DictReader(stdout, delimiter = ':') # Create CSV

                discovered_resource = []
                storwize_logger.info("Starting discovering resource - {0}".format(resource))
                for one_object in resource_in_csv:
                    if ['lsvdisk', 'lsmdisk', 'lsmdiskgrp'].count(resource) == 1:
                        one_object_list = {}
                        one_object_list["{#ID}"] = one_object["id"]
                        one_object_list["{#NAME}"] = one_object["name"] 
                        discovered_resource.append(one_object_list)
                    elif ['lsenclosurebattery', 'lsenclosurepsu', 'lsenclosurecanister'].count(resource) == 1:
                        one_object_list = {}
                        one_object_list["{#ENCLOSURE_ID}"] = one_object["enclosure_id"]
                        if resource == 'lsenclosurebattery':
                            one_object_list["{#BATTERY_ID}"] = one_object["battery_id"]
                        if resource == 'lsenclosurepsu':
                            one_object_list["{#PSU_ID}"] = one_object["PSU_id"]
                        if resource == 'lsenclosurecanister':
                            one_object_list["{#CANISTER_ID}"] = one_object["canister_id"]
                        discovered_resource.append(one_object_list)
                    elif ['lsportfc', 'lsportsas'].count(resource) == 1:
                        one_object_list = {}
                        one_object_list["{#PORT_ID}"] = one_object["port_id"]
                        one_object_list["{#NODE_NAME}"] = one_object["node_name"]
                        discovered_resource.append(one_object_list)
                    elif ['lsenclosure'].count(resource) == 1:
                        one_object_list = {}
                        one_object_list["{#ID}"] = one_object["id"]
                        one_object_list["{#MTM}"] = one_object["product_MTM"]
                        one_object_list["{#SERIAL_NUMBER}"] = one_object["serial_number"]
                        discovered_resource.append(one_object_list)
                    elif ['lsdrive'].count(resource) == 1:
                        one_object_list = {}
                        one_object_list["{#ENCLOSURE_ID}"] = one_object["enclosure_id"]
                        one_object_list["{#SLOT_ID}"] = one_object["slot_id"]
                        discovered_resource.append(one_object_list)
                    else:
                        one_object_list = {}
                        one_object_list["{#ID}"] = one_object["id"]
                        one_object_list["{#ENCLOSURE_ID}"] = one_object["enclosure_id"]
                        discovered_resource.append(one_object_list)

                storwize_logger.info("Succes get resource - {0}".format(resource))

                converted_resource = convert_to_zabbix_json(discovered_resource)
                timestampnow = int(time.time())
                xer.append("%s %s %s %s" % (storage_name, resource, timestampnow, converted_resource))
    except Exception as oops:
        storwize_logger.error("Error occurs in discovering - {0}".format(oops))
        storwize_logout(storwize_connection)
        sys.exit("1100")
        
    storwize_logout(storwize_connection)
    return send_data_to_zabbix(xer, storage_name)

def get_disk_usage(storwize_user, storwize_password, storwize_ip, storwize_port, storage_name):
        storwize_connection = storwize_connect(storwize_user, storwize_password, storwize_ip, storwize_port)
    
        list_resources = []
        try:
            stdin, stdout, stderr = storwize_connection.exec_command('svcinfo lsvdisk -delim :')
            if len(stderr.read()) > 0: # Если случились ошибки, запиши их в лог и выйди из скрипта (If errors occur, then write them to log-file and correctyly end of ssh-session)
                           storwize_logger.error("Error Occurs in SSH Command - {0}".format(stderr.read()))
                           storwize_logout(storwize_connection)
                           sys.exit("1100")
            else:
                           resource_in_csv = csv.DictReader(stdout, delimiter = ':') # Create CSV
                           timestampnow = int(time.time())
                           storwize_logger.info("Starting collecting volume usage - list of volumes")

                           for one_object in resource_in_csv:
                                    list_resources.append(one_object["name"])
                                    storwize_logger.info("detected volume {0}".format(one_object["name"]))
        except Exception as pizdec:
                storwize_logger.error("Error occurs in collecting volume usage - list of volumes - {}".format(pizdec))
                storwize_logout(storwize_connection) # Если возникло исключение, нужно корректно заверешить ssh-сессию (If exception occur, than correctly end of ssh-session)
                sys.exit("1100")

        storwize_logout(storwize_connection)
        storwize_connection = storwize_connect(storwize_user, storwize_password, storwize_ip, storwize_port)

        state_resources = []
        try:
                for resource in list_resources:
                        stdin, stdout, stderr = storwize_connection.exec_command('svcinfo lsvdisk -bytes -delim : {0}'.format(resource))
            
                        if len(stderr.read()) > 0: # Если случились ошибки, запиши их в лог и выйди из скрипта (If errors occur, then write them to log-file and correctyly end of ssh-session)
                                storwize_logger.error('svcinfo lsvdisk -bytes -delim : {0}'.format(resource))
                                storwize_logger.error("Error Occurs in SSH Command - {0}".format(stderr.read()))
                                storwize_logout(storwize_connection)
                                sys.exit("1100")
                        else:
                                resource_in_csv = csv.reader(stdout, delimiter = ':') # Create CSV
                                timestampnow = int(time.time())
                                storwize_logger.info("Starting collecting volume usage - {0}".format(resource))
                                for one_object in resource_in_csv:
                                       if not ''.join(one_object).strip():
                                              continue
                                       storwize_logger.info(str(one_object))
                                       if str(one_object[0]) in 'used_capacity':
                                              storwize_logger.info(str(one_object[0])+" - "+str(one_object[1]))
                                              key_used = 'lsvdisk.usage.[{0}]'.format(resource)
                                              state_resources.append("%s %s %s %s" % (storage_name, key_used, timestampnow,(one_object[1])))
                                       if str(one_object[0]) in 'real_capacity':
                                               storwize_logger.info(str(one_object[0])+" - "+str(one_object[1]))
                                               key_used = 'lsvdisk.real_capacity.[{0}]'.format(resource)
                                               state_resources.append("%s %s %s %s" % (storage_name, key_used, timestampnow,(one_object[1])))
                                       if str(one_object[0]) in 'capacity':
                                               storwize_logger.info(str(one_object[0])+" - "+str(one_object[1]))
                                               key_used = 'lsvdisk.capacity.[{0}]'.format(resource)
                                               state_resources.append("%s %s %s %s" % (storage_name, key_used, timestampnow,(one_object[1])))
                
        except Exception as pizdec:
                 storwize_logger.error("Error occurs in collecting usage {1} - {0}".format(pizdec,resource))
                 storwize_logout(storwize_connection) # Если возникло исключение, нужно корректно заверешить ssh-сессию (If exception occur, than correctly end of ssh-session)
                 sys.exit("1100")

        storwize_logout(storwize_connection) # Завершаем ssh-сессию при успешном выполнении сбора метрик (Correctly end of session after get metrics)
        return send_data_to_zabbix(state_resources, storage_name)

def get_status_resources(storwize_user, storwize_password, storwize_ip, storwize_port, storage_name, list_resources):
    storwize_connection = storwize_connect(storwize_user, storwize_password, storwize_ip, storwize_port)

    state_resources = [] # В этот список будут складываться состояние каждого ресурса (диск, блок питания, ...) в формате zabbix (This list will contain state of every resource (disk, psu, ...) on zabbix format)
    is_there_expansion_enclosure = 0

    try:
        for resource in list_resources:
            stdin, stdout, stderr = storwize_connection.exec_command('svcinfo {0} -delim :'.format(resource))

            if len(stderr.read()) > 0: # Если случились ошибки, запиши их в лог и выйди из скрипта (If errors occur, then write them to log-file and correctyly end of ssh-session)
                storwize_logger.error("Error Occurs in SSH Command - {0}".format(stderr.read()))
                storwize_logout(storwize_connection)
                sys.exit("1100")
            else:
                resource_in_csv = csv.DictReader(stdout, delimiter = ':') # Create CSV
                timestampnow = int(time.time())
                storwize_logger.info("Starting collecting status of resource - {0}".format(resource))

                for one_object in resource_in_csv:
                    if ['lsmdiskgrp'].count(resource) == 1:
                        key_health = "health.{0}.[{1}]".format(resource, one_object["name"])
                        key_overallocation = "overallocation.{0}.[{1}]".format(resource, one_object["name"])
                        key_used = "used.{0}.[{1}]".format(resource, one_object["name"])
                        key_virtual = "virtual.{0}.[{1}]".format(resource, one_object["name"])
                        key_real = "real.{0}.[{1}]".format(resource, one_object["name"])
                        key_free = "free.{0}.[{1}]".format(resource, one_object["name"])
                        key_total = "total.{0}.[{1}]".format(resource, one_object["name"])

                        state_resources.append("%s %s %s %s" % (storage_name, key_health, timestampnow, convert_text_to_numeric(one_object["status"])))
                        state_resources.append("%s %s %s %s" % (storage_name, key_overallocation, timestampnow, one_object["overallocation"]))
                        state_resources.append("%s %s %s %s" % (storage_name, key_used, timestampnow, convert_capacity_to_bytes(one_object["used_capacity"])))
                        state_resources.append("%s %s %s %s" % (storage_name, key_virtual, timestampnow, convert_capacity_to_bytes(one_object["virtual_capacity"])))
                        state_resources.append("%s %s %s %s" % (storage_name, key_real, timestampnow, convert_capacity_to_bytes(one_object["real_capacity"])))
                        state_resources.append("%s %s %s %s" % (storage_name, key_free, timestampnow, convert_capacity_to_bytes(one_object["free_capacity"])))
                        state_resources.append("%s %s %s %s" % (storage_name, key_total, timestampnow, convert_capacity_to_bytes(one_object["capacity"])))

                    elif ['lsenclosurecanister'].count(resource) == 1:
                        key_health = "health.{0}.[{1}.{2}]".format(resource, one_object["enclosure_id"], one_object["canister_id"])
                        state_resources.append("%s %s %s %s" % (storage_name, key_health, timestampnow, convert_text_to_numeric(one_object["status"])))
                    elif ['lsenclosurebattery'].count(resource) == 1:
                        key_health = "health.{0}.[{1}.{2}]".format(resource, one_object["enclosure_id"], one_object["battery_id"])
                        state_resources.append("%s %s %s %s" % (storage_name, key_health, timestampnow, convert_text_to_numeric(one_object["status"])))
                    elif ['lsdrive'].count(resource) == 1:
                        key_health = "health.{0}.[{1}.{2}]".format(resource, one_object["enclosure_id"], one_object["slot_id"])
                        state_resources.append("%s %s %s %s" % (storage_name, key_health, timestampnow, convert_text_to_numeric(one_object["status"])))
                    elif ['lsenclosurepsu'].count(resource) == 1:
                        needed_attributes = ['input_failed', 'output_failed', 'fan_failed']
                        enclosure_id = one_object["enclosure_id"]
                        psu_id = one_object["PSU_id"]
                        advanced_info = advanced_info_of_resource(resource, needed_attributes, storwize_connection, enclosure_id, psu_id)
                        
                        key_input_failed = "inFailed.{0}.[{1}.{2}]".format(resource, one_object["enclosure_id"], one_object["PSU_id"])
                        key_output_failed = "outFailed.{0}.[{1}.{2}]".format(resource, one_object["enclosure_id"], one_object["PSU_id"])
                        key_fan_failed = "fanFailed.{0}.[{1}.{2}]".format(resource, one_object["enclosure_id"], one_object["PSU_id"])
                        key_health = "health.{0}.[{1}.{2}]".format(resource, one_object["enclosure_id"], one_object["PSU_id"])
                        state_resources.append("%s %s %s %s" % (storage_name, key_health, timestampnow, convert_text_to_numeric(one_object["status"])))
                        state_resources.append("%s %s %s %s" % (storage_name, key_input_failed, timestampnow, convert_text_to_numeric(advanced_info["input_failed"])))
                        state_resources.append("%s %s %s %s" % (storage_name, key_output_failed, timestampnow, convert_text_to_numeric(advanced_info["output_failed"])))
                        state_resources.append("%s %s %s %s" % (storage_name, key_fan_failed, timestampnow, convert_text_to_numeric(advanced_info["fan_failed"])))
                    elif ['lsenclosure'].count(resource) == 1:
                        needed_attributes = ['fault_LED']
                        enclosure_id = one_object["id"]
                        advanced_info = advanced_info_of_resource(resource, needed_attributes, storwize_connection, enclosure_id)

                        key_fault_led = "faultLED.{0}.[{1}.{2}]".format(resource, one_object["id"], one_object["serial_number"])
                        key_health = "health.{0}.[{1}.{2}]".format(resource, one_object["id"], one_object["serial_number"])
                        state_resources.append("%s %s %s %s" % (storage_name, key_health, timestampnow, convert_text_to_numeric(one_object["status"])))
                        state_resources.append("%s %s %s %s" % (storage_name, key_fault_led, timestampnow, convert_text_to_numeric(advanced_info["fault_LED"])))

                        if one_object["type"] == "expansion":
                            is_there_expansion_enclosure += 1

                    elif ['lsportfc', 'lsportsas'].count(resource) == 1:
                        key_running = "running.{0}.[{1}.{2}]".format(resource, one_object["port_id"], one_object["node_name"])
                        state_resources.append("%s %s %s %s" % (storage_name, key_running, timestampnow, convert_text_to_numeric(one_object["status"])))
                    elif ['lsvdisk', 'lsmdisk'].count(resource) == 1:
                        key_health = "health.{0}.[{1}]".format(resource, one_object["name"])
                        state_resources.append("%s %s %s %s" % (storage_name, key_health, timestampnow, convert_text_to_numeric(one_object["status"])))

                state_resources.append("%s %s %s %s" %(storage_name, "is_there_expansion_enclosure", timestampnow, is_there_expansion_enclosure))
    except Exception as pizdec:
        storwize_logger.error("Error occurs in collecting status - {}".format(pizdec))
        storwize_logout(storwize_connection) # Если возникло исключение, нужно корректно заверешить ssh-сессию (If exception occur, than correctly end of ssh-session)
        sys.exit("1100")

    storwize_logout(storwize_connection) # Завершаем ssh-сессию при успешном выполнении сбора метрик (Correctly end of session after get metrics)
    return send_data_to_zabbix(state_resources, storage_name)

def main():
    storwize_parser = argparse.ArgumentParser()
    storwize_parser.add_argument('--storwize_ip', action="store", help="Where to connect", required=True)
    storwize_parser.add_argument('--storwize_port', action="store", required=True)
    storwize_parser.add_argument('--storwize_user', action="store", required=True)
    storwize_parser.add_argument('--storwize_password', action="store", required=True)
    storwize_parser.add_argument('--storage_name', action="store", required=True)

    group = storwize_parser.add_mutually_exclusive_group(required=True)
    group.add_argument('--discovery', action ='store_true')
    group.add_argument('--status', action='store_true')
    arguments = storwize_parser.parse_args()

    list_resources = ['lsvdisk', 'lsmdisk', 'lsmdiskgrp', 'lsenclosure', 'lsenclosurebattery', 'lsenclosurepsu', 'lsenclosurecanister', 'lsdrive', 'lsportfc', 'lsportsas']

    if arguments.discovery:
        storwize_logger.info("********************************* Starting Discovering *********************************")
        result_discovery = discovering_resources(arguments.storwize_user, arguments.storwize_password, arguments.storwize_ip, arguments.storwize_port, arguments.storage_name, list_resources)
        print(result_discovery)
    elif arguments.status:
        storwize_logger.info("********************************* Starting Get Status *********************************")
        result_status = get_status_resources(arguments.storwize_user, arguments.storwize_password, arguments.storwize_ip, arguments.storwize_port, arguments.storage_name, list_resources)
        print(result_status)

if __name__ == "__main__":
    main()