manyi/script/simulator/smart_box.py

# -*- coding: utf-8 -*-
# !/usr/bin/env python

import os, sys
import random

PROJECT_ROOT = os.path.join(os.path.abspath(os.path.split(os.path.realpath(__file__))[0] + "/.."), '..')
sys.path.insert(0, PROJECT_ROOT)

import signal
import threading

import simplejson as json
import time
from library.paho.mqtt import client


class MqttClient(client.Client):
    def close(self):
        if self._sock:
            self._sock.close()
            self._sock = None
        if self._sockpairR:
            self._sockpairR.close()
            self._sockpairR = None
        if self._sockpairW:
            self._sockpairW.close()
            self._sockpairW = None


def publish_207(simulator):
    # type: (SimulatorSmartBox)->None

    print('publish_207')

    simulator.today_coins = simulator.today_coins + random.randint(1,5)

    simulator.publish_message(cmd = 207, payload = {
        'signal': 31,
        'cmd': 207,
        'IMEI': simulator.imei,
        'coin': simulator.today_coins
    })

    simulator.start_heart_beat()


simulators = []


def do_ctrl_c(signum, frame):
    print('You choose to stop me.')
    for simulator in simulators:
        simulator.exit()

    exit(0)


signal.signal(signal.SIGINT, do_ctrl_c)
signal.signal(signal.SIGTERM, do_ctrl_c)


class SimulatorSmartBox(object):
    def __init__(self, mqtt_server, mqtt_port, mqtt_user, mqtt_pwd, imei):
        simulators.append(self)

        self.mqtt_server = mqtt_server
        self.mqtt_port = mqtt_port
        self.mqtt_user = mqtt_user
        self.mqtt_pwd = mqtt_pwd
        self.imei = imei
        self.mqtt_client = MqttClient(self.imei)

        self.pwm_wid = 40
        self.pwm_inter = 500
        self.pwm_idle = 1
        self.port = mqtt_port
        self.server = mqtt_server
        self.poweron_reason = 3
        self.soft_ver = '6.12.100'

        self.today_coins = 0

        reponse_201 = self.get_device_info()
        reponse_201.update({
            'rst': 0,
            'cmd': 201
        })
        self.response = {
            201: reponse_201,

            203: {
                'cmd': 203,
                'IMEI': self.imei,
                'rst': 0
            }
        }

    def publish_message(self, cmd, payload, qos = 0):
        self.mqtt_client.publish(topic = 'server/{imei}/{cmd}'.format(imei = self.imei, cmd = cmd),
                                 payload = json.dumps(payload), qos = qos)

    @property
    def driverCode(self):
        assert 'must initial'

    @property
    def driverVersion(self):
        return 'v1.0.0'

    def start(self):
        self.mqtt_client.on_message = self.on_message
        self.mqtt_client.on_connect = self.on_connect
        self.mqtt_client.on_disconnect = self.on_disconnect
        self.mqtt_client.on_subscribe = self.on_subscribe

        self.mqtt_client.username_pw_set(self.mqtt_user, self.mqtt_pwd)

        self.mqtt_client.will_set(topic = "server/{imei}/208".format(imei = self.imei),
                                  payload = json.dumps({
                                      'cmd': 208,
                                      'IMEI': self.imei,
                                      'offline': 1
                                  }))
        self.mqtt_client.connect(self.mqtt_server, self.mqtt_port, 60)

        self.mqtt_client.loop_forever()

    def exit(self):
        self.mqtt_client._thread_terminate = True
        self.mqtt_client.disconnect()
        exit(0)

    def connect_cb(self, client, userdata, flags, rc):
        pass

    def disconnect_cb(self, client, userdata):
        exit(0)

    @property
    def device_extend_info(self):
        assert 'must initial'

    def get_device_info(self):
        device_info = {
            'IMEI': self.imei,
            'signal': 31,
            'pwm_wid': 50,
            'pwm_inter': self.pwm_inter,
            'pwm_idle': self.pwm_idle,
            'ip1': self.server,
            'port1': self.port,
            'poweron_reason': self.poweron_reason,
            'soft_ver': self.soft_ver,
            'mf': 'vivestone',
            'coreVer': 'Luat_V0038_8955_SSL'
        }

        device_info.update(self.device_extend_info)

        return device_info

    def start_heart_beat(self):
        t = threading.Timer(30, publish_207, (self,))
        t.start()

    def do_message(self, cmd, payload):
        # type: (int, dict)->None

        if cmd == 200:
            return

        response = self.response[cmd]

        if cmd in [201, 203]:
            self.publish_message(
                cmd = cmd,
                payload = response)
            return

    def on_subscribe(self, client, userdata, mid, granted_qos):
        print('receive disconnect message. client = %s; userdata = %s; mid = %s, granted_qos = %s' % (
            str(client), str(userdata), mid, granted_qos))

        topic = "server/{imei}/200".format(imei = self.imei)
        shake_message = self.get_device_info()
        shake_message["cmd"] = 200
        shake_message["timestamp"] = long(time.time() * 1000)

        self.publish_message(cmd = 200, payload = shake_message, qos = 1)

        self.start_heart_beat()

    def on_disconnect(self, client, userdata, result):
        print('receive disconnect message. client = %s; userdata = %s; result = %s' % (str(client), str(userdata), result))
        client.unsubscribe('smart_box/{imei}/+'.format(imei = self.imei))

    def on_connect(self, client, userdata, flags, rc):
        print('receive connect message. client = %s; userdata = %s; flags = %s, rc = %s' % (
            str(client), str(userdata), flags, rc))

        topic = 'smart_box/{imei}/+'.format(imei = self.imei)
        client.subscribe(topic = topic, qos = 0)

        self.connect_cb(client, userdata, flags, rc)

    def on_message(self, client, userdata, message):
        print('receive data message. client = %s; userdata = %s; message = %s' % (
            str(client), str(userdata), message))

        msgDict = json.loads(bytes.decode(message.payload))

        print('receive msessage = {}'.format(msgDict))

        imei = msgDict['IMEI']
        if imei != self.imei:
            print 'is not my imei. my %s != %s' % (self.imei, imei)
            return

        cmd = int(msgDict.pop('cmd'))
        self.do_message(cmd, msgDict)

    def on_disconnect(self, client, userdata, rc):
        print('receive disconnect message. client = %s; userdata = %s; rc = %s' % (
            str(client), str(userdata), rc))
        self.disconnect_cb(client, userdata)