#!/usr/bin/env python

import sys
import os
import urllib2
import json
sys.path.append(os.getcwd() + '/../../comm/')
import gzip
import StringIO
import datetime
from plugin_base import BaseSender
import cutils
from cutils import CommUtils
import time

class CFSSender(BaseSender):
    def init(self):
        self.url = cutils.get_url('CFSSender','new_cfs_url','cfs_url')
        self.timeout = float(self.get_config('cfs_timeout'))/1000
        self.is_compress = int(self.get_config('is_compress'))
        self.newurl = self.url
        self.dnstime = 0
        self.dnscachetime = 300
        self.max_retries = 3
        self.retry_delay = 1

    def send_data(self, json_data):
        try:
            curtime = datetime.datetime.now()
            if(self.dnstime ==0 or (curtime - self.dnstime).seconds > self.dnscachetime):
                tempurl = CommUtils.dns_parse(self.url)
                if cutils.check_net(tempurl, self.timeout):
                    self.newurl = tempurl
                self.dnstime = curtime
                self.logger().info("get CFSSender dns ipurl  : %s" % self.newurl)

            req = urllib2.Request(self.newurl)
            req.add_header('Content-Type', 'application/json')
            timeout = self.timeout
            data = json.dumps(json_data).lower()
            if self.is_compress == 1:
                try:
                    in_data = data
                    out = StringIO.StringIO()
                    f = gzip.GzipFile(fileobj=out, mode="wb")
                    f.write(in_data)
                    f.close()
                    data = out.getvalue()
                    req.add_header('Content-Encoding', 'gzip')
                    req.add_header('Content-Length', len(data))
                    self.logger().info("gzip compress before %d, after %d", len(in_data), len(data))
                except Exception, e:
                    self.logger().error(
                        "compress data error, error: %s, original data: %s", str(e), str(in_data))
            for attempt in range(self.max_retries):
                try:
                    http_ret = urllib2.urlopen(req, data, timeout)
                    response = http_ret.read()
                    break
                except urllib2.URLError,e:
                    if attempt < (self.max_retries - 1):
                        self.logger().info("send data error: %s sleep 1s and retry %d/%d" % (str(e),attempt + 1, self.max_retries))
                        time.sleep(self.retry_delay)
                    else:
                        self.logger().error("send data error max_retries , error :%s, data : %s", str(e), data)
                        return
            try:
                json_resp = json.loads(response)
                retcode = int(json_resp["returnCode"])
                if retcode != 0:
                    self.logger().error("cfs send error, retcode : %d, msg : %s, data : %s" %
                                        (retcode, json_resp["msg"], data))
                else:
                    self.logger().info("cfs send succ, data : %s" % str(data))
            except ValueError, e:
                self.logger().error("cfs send error, got a invalid json response : %s" % response)
        except urllib2.URLError, e:
            self.logger().error("send data error , error :%s, data : %s", str(e), data)