#!/usr/local/qcloud/monitor/python26/bin/python
# -*- coding: utf-8 -*-
"""
Parse /proc/self/mountstats and display it in human readable form
"""

import sys
import os, time
import socket

cur_dir = os.path.dirname(os.path.realpath(__file__))
sys.path.append(cur_dir + '/../utils/')
sys.path.append(cur_dir + '/../../base/')
sys.path.append(cur_dir + '/../../../comm/')

from plugin_base import VmBaseCollector
from utils.metric_handler import MetricHandler
from utils.vpc import VpcIdManager
from mountstats import parse_stats_file, DeviceData


class CFSMountStatsCollector(VmBaseCollector):

    def init(self):
        # 获取VPC相关信息的管理器
        self.vpc = VpcIdManager()
        # 设置当前收集器的执行频率
        self.set_frequency(60)
        # 初始化指标处理器并配置对应域和dimensions
        self.handler = MetricHandler()
        self.handler.namespace = 'qce/cfs_tcloud'
        self.handler.dimensions = [
            "cfs_vip",
            "export",
            "mountpoint",
            "opts",
            "version",
            "cvm_ip",
            "cvm_uuid",
            "un_vpc_id",
        ]

    def get_mount_points(self, mount_stats):
        mount_points = []

        for device, desc in mount_stats.items():
            stats = DeviceData()
            stats.parse_stats(desc)
            if stats.is_nfs_mountpoint():
                mount_points += [device]
        if len(mount_points) == 0:
            print('No NFS mount points were found')

        return mount_points

    def get_nfs_version(self, opts):
        for opt in opts:
            if opt.startswith("vers="):
                return opt.split("=")[1]
        return "null"

    def get_cfs_vip(self, export):
        return export.split(":")[0]


    def telnet(self, host, port):
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((host, int(port)))
            s.settimeout(.1)
            s.shutdown(2)
            return 1
        except Exception as e:
            return 0
    def test_vip_port(self,cfs_vip):
        result=[]
        result.append(self.telnet(cfs_vip, 2049))
        result.append(self.telnet(cfs_vip, 111))
        result.append(self.telnet(cfs_vip, 892))
        return result

    def do_collect(self):
        if not os.path.exists('/proc/self/mountstats'):
            return
        with open('/proc/self/mountstats', 'r') as file:
            mount_stats = parse_stats_file(file)

        mount_points = self.get_mount_points(mount_stats)
        if len(mount_points) == 0:
            return
        vip_port_test = {}
        for mp in mount_points:
            stats = DeviceData()
            stats.parse_stats(mount_stats[mp])
            opts = stats.nfs_data['mountoptions']
            mountpoint = stats.nfs_data['mountpoint']
            age = stats.nfs_data['age']
            export = stats.nfs_data['export']
            version = self.get_nfs_version(opts)
            cfs_vip = self.get_cfs_vip(export)

            dimensions = {
                'cvm_uuid': self.get_vm_uuid(),
                'cvm_ip': self.get_vmip(),
                'un_vpc_id': self.vpc.un_vpc_id,
                'cfs_vip': cfs_vip,
                'export': export,
                'mountpoint': mountpoint,
                'opts': ','.join(opts),
                'version': version,
            }
            if cfs_vip and cfs_vip not in vip_port_test:
                vip_port_test[cfs_vip] = self.test_vip_port(cfs_vip)
            metric = [
                {
                    'name': 'age',
                    'value': int(age)
                },
                {
                    'name': 'port_2049',
                    'value': vip_port_test[cfs_vip][0]
                },
                {
                    'name': 'port_111',
                    'value': vip_port_test[cfs_vip][1]
                },
                {
                    'name': 'port_892',
                    'value': vip_port_test[cfs_vip][2]
                },
            ]
            self.handler.add_batch_metric(
                batch=metric,
                dimensions=dimensions,
                timestamp=int(time.time()),
            )
        self.put_data({
            'sender': 'cfs_tcloud_sender',
            'datas': self.handler.pop_metrics()
        })


def main():
    collector = CFSMountStatsCollector()
    collector.init()
    collector.collect()
    collector.dump_data()


if __name__ == '__main__':
    main()