manyi/script/device_upgrade/prepare_update_devices.py

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

import getopt
import os
import sys

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

try:
    options, args = getopt.getopt(sys.argv[1:], 'v:s:e:m:r:p:b:d:a:h:',
                                  ['version=', 'server=', 'env=', 'platform-version=',
                                   'platform=', 'dealer=', 'agent=', 'hwVer='])
except getopt.GetoptError as e:
    print(str(e))
    sys.exit()

upgrade_version = ''
system_env = 'testing'
platform_version = ''
platform = ''
server = ''
dealer = None
agent = None
hwVer = None


def get_fw_url_tmpl(server, platform, platform_version, hwVer):
    if platform == '8955':
        if hwVer:
            fw_url_tmpl = 'http://{server}/uploaded/version/2g/SmartBox_{version}_Luat_V{platform_version}_{platform}_SSL_{hwVer}'.format(
                server = server,
                version = upgrade_version,
                platform_version = '{0:0>4}'.format(platform_version),
                platform = platform,
                hwVer = hwVer)
        else:
            fw_url_tmpl = 'http://{server}/uploaded/version/2g/SmartBox_{version}_Luat_V{platform_version}_{platform}_SSL'.format(
                server = server,
                version = upgrade_version,
                platform_version = '{0:0>4}'.format(platform_version),
                platform = platform)

    elif platform == 'ASR1802':
        if hwVer:
            fw_url_tmpl = 'http://{server}/uploaded/version/4g/SmartBox4G_{version}_Luat_V{platform_version}_{platform}_720D_{hwVer}'.format(
                server = server,
                version = upgrade_version,
                platform_version = '{0:0>4}'.format(platform_version),
                platform = platform,
                hwVer = hwVer)
        else:
            fw_url_tmpl = 'http://{server}/uploaded/version/4g/SmartBox4G_{version}_Luat_V{platform_version}_{platform}_720D'.format(
                server = server,
                version = upgrade_version,
                platform_version = '{0:0>4}'.format(platform_version),
                platform = platform)
    else:
        assert False, 'incorrect platform type.'

    fw_url_tmpl = fw_url_tmpl + '_{driver_code}'

    if platform == 'ASR1802':
        fw_url_tmpl = fw_url_tmpl + '_{full}'

    fw_url_tmpl = fw_url_tmpl + '.bin'

    return fw_url_tmpl


for name, value in options:
    if name in ('-v', '--version'):
        upgrade_version = value

    if name in ('-e', '--env'):
        system_env = value

    if name in ('-r', '--platform-version'):
        platform_version = value

    if name in ('-p', '--platform'):
        platform = value

    if name in ('-s', '--server'):
        server = value

    if name in ('-d', '--dealer'):
        dealer = value

    if name in ('-a', '--agent'):
        agent = value

    if name in ('-h', '--hwVer'):
        hwVer = value

if not server:
    print 'server is null.'
    sys.exit(2)

if not platform_version or not platform:
    print 'not assign platform info.'
    sys.exit(2)

if platform not in ('8955', 'ASR1802'):
    print 'incorrect platform type.'
    sys.exit(2)

if not upgrade_version:
    print 'error version = {version}'.format(version = upgrade_version)
    sys.exit(2)

master, major, minor = upgrade_version.split('.')
if not master or not major or not minor:
    print 'error version = {version}'.format(version = upgrade_version)
    sys.exit(2)

if not system_env:
    print 'error system env = {env}'.format(env = system_env)
    sys.exit(2)

import os

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'configs.{env}'.format(env = system_env))

from script.base import init_env

init_env(interactive = False)

from script.device_upgrade import DeviceUpgradeLog
from apps.web.device.models import Device, DeviceDict
from apps.web.constant import DeviceOnlineStatus
from apps.web.dealer.models import Dealer

version_regex = 'v{master}\.{major}\.'.format(master = master, major = major)
version_check = 'v{master}.{major}.'.format(master = master, major = major)
upgrade_soft_ver = 'v{version}'.format(version = upgrade_version)

if platform == 'ASR1802':
    upgrade_core_ver = 'Luat_V{platform_version}_{platform}_720D'.format(
        platform_version = '{0:0>4}'.format(platform_version),
        platform = platform)
else:
    upgrade_core_ver = 'Luat_V{platform_version}_{platform}_SSL'.format(
        platform_version = '{0:0>4}'.format(platform_version),
        platform = platform)

fw_url_tmpl = get_fw_url_tmpl(server, platform, platform_version, hwVer)

update_key = DeviceUpgradeLog.make_update_key(upgrade_core_ver, upgrade_soft_ver)

print 'version regex is: {}'.format(version_regex)
print 'version check is: {}'.format(version_check)
print 'upgrade soft version is: {}'.format(upgrade_soft_ver)
print 'fw url tmpl is: {}'.format(fw_url_tmpl)
print 'update key is: {}'.format(update_key)

exists_code = set()
no_exists_code = set()

try:
    if dealer:
        dealers = [dealer]
    elif agent:
        dealers = [dealer['_id'] for dealer in Dealer.get_collection().find({'agentId': agent})]
    else:
        dealers = None

    common_filter = {}

    if hwVer:
        if hwVer == 'v3':
            filter = {
                '$and': [
                    {
                        '$or': [{'hwVer': hwVer},
                                {'softVer': {'$regex': 'v4\.0\.'}},
                                {'softVer': {'$regex': 'v3\.0\.'}},
                                {'softVer': {'$regex': 'v5\.15\.'}}]
                    },
                    {
                        'softVer': {'$ne': upgrade_soft_ver}
                    }
                ]
            }
            filter.update(common_filter)
        else:
            raise Exception('暂时不支持')
    else:
        if version_check == 'v1.8.':
            filter = {
                '$and': [
                    {
                        '$or': [
                            {'softVer': 'v1.5'},
                            {'softVer': 'v1.7'},
                            {'softVer': {'$regex': 'v1\.5\.'}},
                            {'softVer': {'$regex': 'v1\.7.'}},
                            {'softVer': {'$regex': version_regex}}]
                    },
                    {
                        'softVer': {'$ne': upgrade_soft_ver}
                    }
                ]
            }
            filter.update(common_filter)
        elif version_check == 'v5.15.':
            filter = {
                '$and': [
                    {
                        '$or': [{'softVer': {'$regex': 'v4\.0\.'}},
                                {'softVer': {'$regex': 'v3\.0\.'}},
                                {'softVer': {'$regex': version_regex}}]
                    },
                    {
                        'softVer': {'$ne': upgrade_soft_ver}
                    }
                ]
            }
            filter.update(common_filter)
        elif version_check == 'v5.13.':
            filter = {
                '$and': [
                    {
                        '$or': [{'softVer': {'$regex': 'v3\.1\.'}},
                                {'softVer': {'$regex': 'v4\.1\.'}},
                                {'softVer': {'$regex': version_regex}}]
                    },
                    {
                        'softVer': {'$ne': upgrade_soft_ver}
                    }
                ]
            }
            filter.update(common_filter)
        elif version_check == 'v5.1.':
            filter = {
                '$and': [
                    {
                        '$or': [{'softVer': {'$regex': 'v40\.1\.'}}, {'softVer': {'$regex': version_regex}}]
                    },
                    {
                        'softVer': {'$ne': upgrade_soft_ver}
                    }
                ]
            }
            filter.update(common_filter)
        elif version_check == 'v5.12.':
            filter = {
                '$and': [
                    {
                        '$or': [{'softVer': {'$regex': 'v4\.12\.'}}, {'softVer': {'$regex': version_regex}}]
                    },
                    {
                        'softVer': {'$ne': upgrade_soft_ver}
                    }
                ]
            }
            filter.update(common_filter)
        else:
            filter = {
                '$and': [{'softVer': {'$regex': version_regex}}, {'softVer': {'$nin': [upgrade_soft_ver, 'v5.100.10']}}]
            }
            filter.update(common_filter)

    if dealers:
        filter.update({
            'ownerId': {'$in': dealers}
        })

    exists_dev_list = [item.devNo for item in DeviceUpgradeLog.objects(updateKey = update_key)]
    if exists_dev_list:
        filter.update({
            'devNo': {'$nin': exists_dev_list}
        })

    devNoList = []

    objs = Device.get_collection().find(filter)
    for obj in objs:
        if ':1883' not in obj['server']:
            continue

        now_soft_ver = str(obj['softVer'])
        dev_no = str(obj['devNo'])

        need_upgrade = True
        try:
            common_flag = (now_soft_ver.startswith(version_check) and now_soft_ver != upgrade_soft_ver)

            if hwVer:
                common_flag = common_flag or (obj['hwVer'] == hwVer)

                if hwVer == 'v3':
                    if now_soft_ver.startswith('v4.0.') or \
                            now_soft_ver.startswith('v3.0.') or \
                            now_soft_ver.startswith("v5.15.") or \
                            common_flag:
                        devNoList.append(dev_no)
                        continue
                else:
                    raise Exception('unsupport hw version.')
            else:
                if version_check == 'v1.8.':
                    if now_soft_ver.startswith('v1.7.') or now_soft_ver.startswith(
                            'v1.5.') or now_soft_ver == 'v1.7' or now_soft_ver == 'v1.5' or common_flag:
                        devNoList.append(dev_no)
                        continue
                elif version_check == 'v5.15.':
                    if now_soft_ver.startswith('v4.0.') or now_soft_ver.startswith('v3.0.') or common_flag:
                        devNoList.append(dev_no)
                        continue
                elif version_check == 'v5.1.':
                    if now_soft_ver.startswith('v40.1.') or common_flag:
                        devNoList.append(dev_no)
                        continue
                elif version_check == 'v5.12.':
                    if now_soft_ver.startswith('v4.12.') or common_flag:
                        devNoList.append(dev_no)
                        continue
                elif version_check == 'v5.13.':
                    if now_soft_ver.startswith('v3.1.') or now_soft_ver.startswith('v4.1.') or common_flag:
                        devNoList.append(dev_no)
                        continue
                else:
                    if common_flag:
                        devNoList.append(dev_no)
                        continue

            need_upgrade = False
        finally:
            if not need_upgrade:
                print 'dev<devNo={},rCode={},code={}> version is: {}. no need to upgrade'.format(dev_no,
                                                                                                 obj.get('devType',
                                                                                                         {}).get(
                                                                                                     'code', ''),
                                                                                                 obj.get(
                                                                                                     'driverCode',
                                                                                                     ''),
                                                                                                 now_soft_ver)
            else:
                print 'dev<devNo={},rCode={},code={}> version is: {}. need to upgrade.'.format(dev_no,
                                                                                               obj.get('devType',
                                                                                                       {}).get(
                                                                                                   'code', None),
                                                                                               obj.get('driverCode',
                                                                                                       ''),
                                                                                               now_soft_ver)

    for devNo in devNoList:
        try:
            dev = Device.get_dev(devNo)  # type: DeviceDict

            if upgrade_soft_ver == dev.softVer:
                print('{} is newest version'.format(dev.softVer))
                continue

            if version_check != 'v5.100.' and dev.online != DeviceOnlineStatus.DEV_STATUS_ONLINE:
                print '{} is offline.'.format(devNo)
                continue

            if version_check in ['v1.8.', 'v5.15.']:
                driver_code = '000000'
            else:
                devType = dev.devType
                devTypeCode = devType.get('code', None)

                print devTypeCode

                if devTypeCode and devTypeCode < '100100':
                    driver_code = '100000'
                else:
                    if 'driverCode' in dev and dev['driverCode']:
                        driver_code = dev['driverCode']
                        if driver_code == '100205':
                            driver_code = '100210'
                    else:
                        print('{} has no driver code.'.format(devNo))
                        driver_code = '100000'

            if platform == 'ASR1802':
                if upgrade_core_ver == dev['coreVer']:
                    version_path = fw_url_tmpl.format(driver_code = driver_code, full = 'inc')
                else:
                    version_path = fw_url_tmpl.format(driver_code = driver_code, full = 'full')
            else:
                version_path = fw_url_tmpl.format(driver_code = driver_code)

            print 'version path is: {}'.format(version_path)

            cmdPara = {'cmd': 202, 'IMEI': devNo, 'ota_set': {'fw_url': version_path}}
            print cmdPara

            try:
                log = DeviceUpgradeLog.new_log(dev = dev,
                                               coreVer = upgrade_core_ver,
                                               softVer = upgrade_soft_ver,
                                               driverCode = driver_code,
                                               updatePara = cmdPara)
            except Exception, e:
                print str(e)
                continue

        except Exception, e:
            print 'some exception =%s' % e
finally:
    print('finished')