import sys
import os,time
sys.path.append(os.getcwd() + '/../../../comm/')
import constant
from plugin_base import VmBaseCollector
from utils.collect_tool import TcpCollect
from utils.metric_handler import MetricHandler
from cutils import generate_config

TCP_CONF = '../etc/config.ini'

class TcpCollector(VmBaseCollector):
    def init(self):
        self.set_frequency(10)
        self.collector = TcpCollect()
        self.handler = MetricHandler()
        self.handler.namespace = 'qce/cvm'
        self.handler.dimensions = [ 'vm_uuid', 'vmip']
        self.last_tcp_status = {}
        self.last_conntrack = {}
        self._getTcpStatusFlag = False
        # check whether the get_tcp_status flag been on
        item_dict = generate_config(TCP_CONF, 'tcpStatus')
        if item_dict.has_key('get_tcp_status') and item_dict['get_tcp_status'].lower() == 'true':
            self._getTcpStatusFlag = True

    def do_collect(self):
        now = int(time.time())
        tcp_status = {}
        batch_metric = []
        vm_uuid = self.get_vm_uuid()
        vmip = self.get_vmip()

        tcp_netstat = self.collector.getTcpNetstat()
        conntrack_dict = self.collector.get_tcp_drop_stat()
        tcp_time_await = self.collector.getTimeAwait()
        snmp_info = self.collector.get_net_info()
        dimensions = {'vm_uuid': vm_uuid, 'vmip': vmip }  # docker master node, needn't clusterid
        if snmp_info['tcp_conn_active'] != -1:
            metric = {'name': 'tcp_conn_active', 'value': snmp_info['tcp_conn_active'], 'unit': 'count'}
            batch_metric.append(metric)
        if snmp_info['tcp_conn_passive'] != -1:
            metric = {'name': 'tcp_conn_Passive', 'value': snmp_info['tcp_conn_passive'], 'unit': 'count'}
            batch_metric.append(metric)
        if snmp_info['tcp_attempt_fails'] != -1:
            metric = {'name': 'tcp_attempt_fails', 'value': snmp_info['tcp_attempt_fails'], 'unit': 'count'}
            batch_metric.append(metric)
        if snmp_info['tcp_curr_estab'] != -1:
            metric = {'name':'tcp_curr_estab', 'value': snmp_info['tcp_curr_estab'], 'unit':'count'}
            batch_metric.append(metric)
        if snmp_info['udp_recv_speed'] != -1:
            metric = {'name': 'udp_in_datagrams', 'value': snmp_info['udp_recv_speed'], 'unit': 'count'}
            batch_metric.append(metric)
        if snmp_info['udp_send_speed'] != -1:
            metric = {'name': 'udp_out_datagrams', 'value': snmp_info['udp_send_speed'], 'unit': 'count'}
            batch_metric.append(metric)
        if snmp_info['udp_inerrors_speed'] != -1:
            metric = {'name': 'udp_in_errors', 'value': snmp_info['udp_inerrors_speed'], 'unit': 'count'}
            batch_metric.append(metric)
        if snmp_info['udp_rcvbuerrors_speed'] != -1:
            metric = {'name': 'udp_rcvbu_errors', 'value': snmp_info['udp_rcvbuerrors_speed'], 'unit': 'count'}
            batch_metric.append(metric)
        if snmp_info['udp_sndbuferrors_speed'] != -1:
            metric = {'name': 'udp_sndbuf_errors', 'value': snmp_info['udp_sndbuferrors_speed'], 'unit': 'count'}
            batch_metric.append(metric)
        if snmp_info['ip_reasmfails_speed'] != -1:
            metric = {'name': 'ip_reasm_fails', 'value': snmp_info['ip_reasmfails_speed'], 'unit': 'count'}
            batch_metric.append(metric)
        if self._getTcpStatusFlag:
            tcp_status = self.collector.getTcpStatus()
        if tcp_status:
            batch_metric = [
                {'name':'tcp_close_wait', 'value':tcp_status["CLOSE_WAIT"], 'unit':'count'},
                {'name':'tcp_listen', 'value':tcp_status["LISTEN"], 'unit':'count'},
                {'name':'tcp_syn_sent', 'value':tcp_status["SYN_SENT"], 'unit':'count'},
                {'name':'tcp_syn_rcvd', 'value':tcp_status["SYN_RECV"], 'unit':'count'},
                {'name':'tcp_fin_wait_1', 'value':tcp_status["FIN_WAIT1"], 'unit':'count'},
                {'name':'tcp_fin_wait_2', 'value':tcp_status["FIN_WAIT2"], 'unit':'count'}
            ]
        metric = {'name':'tcp_time_await', 'value':tcp_time_await, 'unit':'count'}
        batch_metric.append(metric)
        if len(self.last_tcp_status) != 0:
            timeout_count = tcp_netstat["TCPTimeouts"] - self.last_tcp_status['TCPTimeouts']
            retrans_count = tcp_netstat["TCPFastRetrans"] - self.last_tcp_status['TCPFastRetrans']
            lisdrop_count = tcp_netstat["ListenDrops"] - self.last_tcp_status['ListenDrops']
            lisoverflows_count = tcp_netstat["ListenOverflows"] - self.last_tcp_status['ListenOverflows']
            fulldrop_count = tcp_netstat["TCPReqQFullDrop"] - self.last_tcp_status['TCPReqQFullDrop']
            tcp_tw_recycle = tcp_netstat["PAWSPassive"] - self.last_tcp_status['PAWSPassive']
            nfct_drop = conntrack_dict.get("drop", 0) - self.last_conntrack.get("drop", 0)
            nfct_insert_fail = conntrack_dict.get("insert_failed", 0) - self.last_conntrack.get("insert_failed", 0)
            nfct_invalid = conntrack_dict.get("invalid", 0) - self.last_conntrack.get("invalid", 0)
            
            metric = {'name': 'tcp_timeouts', 'value': timeout_count, 'unit': 'count'}
            batch_metric.append(metric)
            metric = {'name': 'tcp_fastretrans', 'value': retrans_count, 'unit': 'count'}
            batch_metric.append(metric)
            metric = {'name': 'tcp_listendrops', 'value': lisdrop_count, 'unit': 'count'}
            batch_metric.append(metric)
            metric = {'name': 'tcp_listenoverflows', 'value': lisoverflows_count, 'unit': 'count'}
            batch_metric.append(metric)
            metric = {'name': 'tcp_reqqfulldrop', 'value': fulldrop_count, 'unit': 'count'}
            batch_metric.append(metric)
            metric = {'name': 'tcp_tw_recycle', 'value': tcp_tw_recycle, 'unit': 'count'}
            batch_metric.append(metric)
            metric = {'name': 'nfct_drop', 'value': nfct_drop, 'unit': 'count'}
            batch_metric.append(metric)
            metric = {'name': 'nfct_insert_fail', 'value': nfct_insert_fail, 'unit': 'count'}
            batch_metric.append(metric)
            metric = {'name': 'nfct_invalid', 'value': nfct_invalid, 'unit': 'count'}
            batch_metric.append(metric)

        self.last_tcp_status.update(tcp_netstat)
        self.last_conntrack.update(conntrack_dict)

        self.handler.add_batch_metric(batch = batch_metric,dimensions = dimensions, timestamp = now)
        if (len( self.handler.get_metrics()) > 0) :
            data = {'sender': 'nws_sender', 'datas': self.handler.pop_metrics()}
            self.put_data(data)

def main():
    collector = TcpCollector()
    collector.init()
    for i in range(10):
        collector.collect()
        collector.dump_data()
        time.sleep(10)

if __name__ == '__main__':
    TCP_CONF = '../../../etc/config.ini'
    main()