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")