import aioredis import asynctest import redis try: import ujson as json except ImportError: import json import pydatacoll.utils.logger as my_logger from pydatacoll.resources.protocol import * from pydatacoll.resources.redis_key import * from test.mock_device import mock_data, iec104device from pydatacoll import api_server from pydatacoll.utils.read_config import * logger = my_logger.get_logger('TestInterface') class RedisTest(asynctest.TestCase): async def test_connect_timeout(self): try: loop = asyncio.get_event_loop() reader, writer = await asyncio.open_connection(config.get('REDIS', 'host', fallback='127.0.0.1'), config.getint('REDIS', 'port', fallback=6379), loop=loop) loop.call_later(1, lambda w: w.close(), writer) data = await reader.readexactly(100) logger.debug('Received: %r', data.decode()) # print("data={}".format(data)) self.assertEqual(len(data), 0) except asyncio.IncompleteReadError: logger.debug('stream closed!')
# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import importlib from pydatacoll.plugins import BaseModule from pydatacoll.utils.func_container import param_function import pydatacoll.utils.logger as my_logger logger = my_logger.get_logger('DeviceManager') class DeviceManager(BaseModule): device_dict = dict() protocol_dict = dict() async def start(self): try: device_dict = self.redis_client.smembers('SET:DEVICE') for device_id in device_dict: device_dict = self.redis_client.hgetall('HS:DEVICE:{}'.format(device_id)) if device_dict: await self.add_device(None, device_dict) except Exception as ee: logger.error('init_devices failed: %s', repr(ee), exc_info=True)
import asyncio from pydatacoll.protocols import BaseDevice import pydatacoll.utils.logger as my_logger logger = my_logger.get_logger('FORMULADevice') class FORMULADevice(BaseDevice): def __init__(self, device_info: dict, io_loop: asyncio.AbstractEventLoop): super(FORMULADevice, self).__init__(device_info, io_loop) def disconnect(self, reconnect=False): pass def send_frame(self, frame, check=True): pass def prepare_ctrl_frame(self, term_item_dict, value): pass def prepare_call_frame(self, term_item_dict): pass def fresh_task(self, term_dict, term_item_dict, delete=False): pass
import asyncio import datetime import redis try: import ujson as json except ImportError: import json from abc import ABCMeta, abstractmethod from pydatacoll.utils import logger as my_logger from pydatacoll.utils.read_config import * logger = my_logger.get_logger('BaseDevice') class BaseDevice(object, metaclass=ABCMeta): def __init__(self, device_info: dict, io_loop: asyncio.AbstractEventLoop): self.connected = False self.device_info = device_info self.device_id = self.device_info['id'] self.io_loop = io_loop or asyncio.get_event_loop() self.redis_client = redis.StrictRedis(db=config.getint('REDIS', 'db', fallback=1), decode_responses=True) async def save_frame(self, frame, send=True, save_time=datetime.datetime.now()): try: self.redis_client.rpush( "LST:FRAME:{}".format(self.device_id), '{time},{type},{frame}'.format( time=save_time.isoformat(), type="send" if send is True else "recv", frame=frame.hex())) except Exception as e: logger.error("device[%s] save_frame failed: %s", self.device_id, repr(e))
# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import asyncio from abc import abstractmethod, ABCMeta import aioredis import redis import pydatacoll.utils.logger as my_logger from pydatacoll.utils.func_container import ParamFunctionContainer from pydatacoll.utils.read_config import * logger = my_logger.get_logger('BaseModule') class BaseModule(ParamFunctionContainer, metaclass=ABCMeta): def __init__(self, io_loop: asyncio.AbstractEventLoop = None): super().__init__() self.io_loop = io_loop or asyncio.get_event_loop() self.sub_client = self.io_loop.run_until_complete( aioredis.create_redis((config.get('REDIS', 'host', fallback='localhost'), config.getint('REDIS', 'port', fallback=6379)), db=config.getint('REDIS', 'db', fallback=1))) self.redis_client = redis.StrictRedis(db=config.getint('REDIS', 'db', fallback=1), decode_responses=True) self.initialized = False self.sub_tasks = list() self.sub_channels = list() self.channel_router = dict()
import asyncio import datetime try: import ujson as json except ImportError: import json import asynctest import pymysql import redis import aioredis import pydatacoll.utils.logger as my_logger import pydatacoll.plugins.db_save as db_save from pydatacoll.utils.read_config import * logger = my_logger.get_logger('DBSaverTest') class DBSaverTest(asynctest.TestCase): loop = None # make pycharm happy def setUp(self): super(DBSaverTest, self).setUp() self.conn = pymysql.Connect(**db_save.PLUGIN_PARAM) self.cursor = self.conn.cursor() self.cursor.execute("DROP TABLE IF EXISTS test_db_save") self.cursor.execute(""" CREATE TABLE test_db_save( id INT AUTO_INCREMENT PRIMARY KEY, device_id VARCHAR(32), term_id VARCHAR(32), item_id VARCHAR(32),
import asyncio import aioredis import asynctest import redis import pydatacoll.utils.logger as my_logger from pydatacoll.protocols.iec104.device import IEC104Device from pydatacoll.protocols.iec104.frame import * from test.mock_device.iec104device import IEC104Device as MockDevice, create_servers from test.mock_device import mock_data from pydatacoll.utils.read_config import * logger = my_logger.get_logger('IEC104DeviceTest') class IEC104DeviceTest(asynctest.TestCase): loop = asyncio.get_event_loop() # make pycharm happy def setUp(self): self.redis_client = redis.StrictRedis(db=config.getint('REDIS', 'db', fallback=1), decode_responses=True) self.server_list = list() mock_data.generate() self.server_list = create_servers(self.loop) def tearDown(self): for server in self.server_list: server.close() self.loop.run_until_complete(server.wait_closed()) async def test_connect(self): device = IEC104Device(mock_data.device1, self.loop)
# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import asyncio from collections import deque from pydatacoll.protocols import BaseDevice import pydatacoll.utils.logger as my_logger from .frame import * logger = my_logger.get_logger('IEC104Device') class IEC104Device(BaseDevice): def __init__(self, device_info: dict, io_loop: asyncio.AbstractEventLoop): super(IEC104Device, self).__init__(device_info, io_loop) self.coll_interval = datetime.timedelta(seconds=config.getint('IEC104', 'coll_interval', fallback=900)) self.coll_count = 0 self.ssn = 0 self.rsn = 0 self.k = 0 self.w = 0 self.send_list = deque() self.last_call_all_time_begin = datetime.datetime.now() self.last_call_all_time_end = None self.connect_retry_count = 0
import unittest import pydatacoll.utils.logger as my_logger from pydatacoll.utils.func_container import ParamFunctionContainer, param_function from pydatacoll.utils import str_to_number logger = my_logger.get_logger('UtilTest') class UtilTest(unittest.TestCase): def test_func_container(self): class MyAPI(ParamFunctionContainer): def __init__(self, a, b, c): super().__init__() self.a = a self.b = b self.c = c @param_function(method='GET', url='/devices') def api_device_list(self, request): logger.debug('api_device_list req=%s', request) @param_function(method='POST', url='/devices_new') def api_new_device(self, request): logger.debug('api_new_device req=%s', request) api = MyAPI(1, 2, 3) self.assertDictEqual(api.module_arg_dict, {'api_device_list': {'method': 'GET', 'url': '/devices'}, 'api_new_device': {'method': 'POST', 'url': '/devices_new'}}) def test_str_to_number(self):
from collections import namedtuple import math import datetime try: import ujson as json except ImportError: import json import pymysql from pydatacoll.plugins import BaseModule from pydatacoll.utils.asteval import Interpreter from pydatacoll.utils.func_container import param_function import pydatacoll.utils.logger as my_logger from pydatacoll.utils.read_config import * logger = my_logger.get_logger('DBSaver') PLUGIN_PARAM = dict( host=config.get('MYSQL', 'host', fallback='127.0.0.1'), port=config.getint('MYSQL', 'port', fallback=3306), user=config.get('MYSQL', 'user', fallback='pydatacoll'), password=config.get('MYSQL', 'password', fallback='pydatacoll'), db=config.get('MYSQL', 'db', fallback='pydatacoll'), ) class DBSaver(BaseModule): # not_implemented = True interp = Interpreter(use_numpy=False) conn = None cursor = None save_unchanged = config.getboolean('DBSaver', 'save_unchanged', fallback=False)
import random import functools import asyncio from collections import defaultdict from collections import deque import redis import pydatacoll.utils.logger as my_logger from pydatacoll.protocols.iec104.frame import * from pydatacoll.utils import str_to_number from pydatacoll.utils.read_config import * logger = my_logger.get_logger("MockIEC104") # 模拟104从站 class IEC104Device: frame_list = defaultdict(list) def __init__(self, device, reader, writer): self.io_loop = asyncio.get_event_loop() self.device_id = device["id"] self.redis = redis.StrictRedis(db=config.getint("REDIS", "db", fallback=1), decode_responses=True) self.coll_interval = datetime.timedelta(minutes=config.getint("IEC104", "coll_interval", fallback=15)) self.coll_count = 0 self.ssn = 0 self.rsn = 0 self.k = 0 self.w = 0 self.send_list = deque() self.last_call_all_time_begin = None
import asyncio import datetime try: import ujson as json except ImportError: import json import asynctest import redis import pandas as pd import numpy as np import pydatacoll.utils.logger as my_logger import pydatacoll.plugins.formula_calc as formula_calc from test.mock_device import mock_data from pydatacoll.utils.read_config import * logger = my_logger.get_logger('FormulaCalcTest') class FormulaCalcTest(asynctest.TestCase): loop = None # make pycharm happy def setUp(self): super(FormulaCalcTest, self).setUp() self.redis_client = redis.StrictRedis(db=config.getint('REDIS', 'db', fallback=1), decode_responses=True) mock_data.generate() self.formula_calc = formula_calc.FormulaCalc(self.loop) self.loop.run_until_complete(self.formula_calc.install()) def tearDown(self): self.loop.run_until_complete(self.formula_calc.uninstall())
from collections import namedtuple import math import datetime try: import ujson as json except ImportError: import json from pydatacoll.utils.asteval import Interpreter import numpy as np import pandas as pd from pydatacoll.plugins import BaseModule from pydatacoll.utils.func_container import param_function import pydatacoll.utils.logger as my_logger from pydatacoll.utils.read_config import * logger = my_logger.get_logger('FormulaCalc') class FormulaCalc(BaseModule): # not_implemented = True formula_dict = dict() # HS:TERM_ITEM:{term_id}:{item_id} -> value of HS:FORMULA:{formula_id} pandas_dict = dict() # HS:DATA:{formula_id}:{term_id}:{item_id} -> pandas.Series interp = Interpreter(use_numpy=False) calc_unchanged = config.getboolean('FormulaCalc', 'calc_unchanged', fallback=False) async def start(self): try: self.interp.symtable['np'] = np self.interp.symtable['pd'] = pd formula_list = self.redis_client.smembers('SET:FORMULA') for formula_id in formula_list:
import asyncio from abc import abstractmethod, ABCMeta import aioredis import redis import pydatacoll.utils.logger as my_logger from pydatacoll.utils.func_container import ParamFunctionContainer from pydatacoll.utils.read_config import * logger = my_logger.get_logger("BaseModule") class BaseModule(ParamFunctionContainer, metaclass=ABCMeta): def __init__(self, io_loop: asyncio.AbstractEventLoop = None): super().__init__() self.io_loop = io_loop or asyncio.get_event_loop() self.sub_client = self.io_loop.run_until_complete( aioredis.create_redis( (config.get("REDIS", "host", fallback="localhost"), config.getint("REDIS", "port", fallback=6379)), db=config.getint("REDIS", "db", fallback=1), ) ) self.redis_client = redis.StrictRedis(db=config.getint("REDIS", "db", fallback=1), decode_responses=True) self.initialized = False self.sub_tasks = list() self.sub_channels = list() self.channel_router = dict() self._register_channel() # logger.info('plugin %s initialized', type(self).__name__) def _register_channel(self):
import asynctest import aiohttp import pymysql import redis try: import ujson as json except ImportError: import json import pydatacoll.utils.logger as my_logger from pydatacoll import api_server from pydatacoll.plugins import db_save from pydatacoll.plugins.device_manage import DeviceManager from test.mock_device.iec104device import create_servers logger = my_logger.get_logger('LoadTest') class LoadTest(asynctest.TestCase): loop = asyncio.get_event_loop() # make pycharm happy def setUp(self): logger.info('prepare data..') self.redis_client = redis.StrictRedis(db=1, decode_responses=True) self.redis_client.flushdb() self.redis_client.hmset('HS:DEVICE:0', {'id': 0, 'name': '测试集中器0', 'ip': '127.0.0.1', 'port': 2404, 'protocol': 'iec104'}) self.redis_client.sadd('SET:DEVICE', 0) self.conn = pymysql.Connect(**db_save.PLUGIN_PARAM) self.cursor = self.conn.cursor() self.cursor.execute("DROP TABLE IF EXISTS test_data_check")