|
|
import ast
|
|
|
import socket
|
|
|
import struct
|
|
|
import time
|
|
|
import typing
|
|
|
|
|
|
from modbus_tk import defines as cst
|
|
|
from modbus_tk.exceptions import ModbusError
|
|
|
from modbus_tk.modbus_tcp import TcpMaster
|
|
|
|
|
|
import socket
|
|
|
import json
|
|
|
from Agreement.FQ.skio import exception
|
|
|
from Agreement.FQ.skio.define import IDev, IVar, T_Val, ValType, SigType, LOGGER
|
|
|
|
|
|
from Agreement.FQ.skio.define import IDev, IVar, T_Val, ValType, SigType
|
|
|
from utils.WorkModels import PointModel
|
|
|
import time
|
|
|
|
|
|
import re
|
|
|
|
|
|
_T_OUTPUT_VALUE = typing.Union[typing.Tuple[int], typing.List[int], int]
|
|
|
Type_Dic = {
|
|
|
SigType.FAI: 1,
|
|
|
SigType.FAV: 2,
|
|
|
SigType.FDO: 3,
|
|
|
SigType.FPT100: 4,
|
|
|
SigType.FAO: 1,
|
|
|
SigType.FDI: 3,
|
|
|
|
|
|
}
|
|
|
|
|
|
# 他们给定的 rpc1_1:5 rpc2_1:6 rpc3_1:7 rpc4_1:8 rpc1_2:1 rpc2_2:2 rpc3_2:3 rpc4_2:4
|
|
|
refer_dic = {
|
|
|
'RPC1_1': 5,
|
|
|
'RPC2_1': 6,
|
|
|
'RPC3_1': 7,
|
|
|
'RPC4_1': 8,
|
|
|
'RPC1_2': 1,
|
|
|
'RPC2_2': 2,
|
|
|
'RPC3_2': 3,
|
|
|
'RPC4_2': 4
|
|
|
}
|
|
|
|
|
|
|
|
|
class TXS_PXI_Dev(IDev, TcpMaster):
|
|
|
'''
|
|
|
设备表，主要有两种类型：
|
|
|
1.modbus协议，用于和下位机对接
|
|
|
2.socket协议，用于和linux server对接
|
|
|
'''
|
|
|
_slave: int = 1
|
|
|
|
|
|
def __init__(self):
|
|
|
IDev.__init__(self)
|
|
|
TcpMaster.__init__(self)
|
|
|
|
|
|
def setup(self, uri):
|
|
|
host, port = uri.split(':')
|
|
|
self._host = host
|
|
|
self._port = int(port)
|
|
|
|
|
|
def write(self, var: IVar, value: T_Val) -> T_Val:
|
|
|
if var.trans_value:
|
|
|
value = var.trans_value
|
|
|
|
|
|
# TODO:应用在福清txs_pxi通信
|
|
|
if isinstance(var.sig_type, str):
|
|
|
var.sig_type = SigType[var.sig_type.upper()]
|
|
|
|
|
|
if var.sig_type in (SigType.FAI, SigType.FAO, SigType.FDI, SigType.FDO, SigType.FAV, SigType.FPT100):
|
|
|
channel = str(var.channel)
|
|
|
rpc, in_or_out = var.uri.split(':')
|
|
|
if re.search(r'(\d+)', in_or_out):
|
|
|
in_or_out_value = re.search(r'(\d+)', in_or_out).groups()[0]
|
|
|
else:
|
|
|
raise exception.SkError(exception.UNSUPPORTED_TYPE,
|
|
|
f'{var.name} uri中没有(IN|OUT)的值 ')
|
|
|
if 'RPC' in rpc.upper():
|
|
|
if var.sig_type == SigType.FAI:
|
|
|
self.clear_channel_ai(f'{rpc}_{channel}_CHANNEL')
|
|
|
|
|
|
var_start: PointModel = PointModel.get(PointModel.sig_name == f'{rpc}_{channel}_START_VALUE')
|
|
|
var_channel: PointModel = PointModel.get(PointModel.sig_name == f'{rpc}_{channel}_CHANNEL')
|
|
|
var_type: PointModel = PointModel.get(PointModel.sig_name == f'{rpc}_{channel}_TYPE')
|
|
|
var_trigger: PointModel = PointModel.get(PointModel.sig_name == f'{rpc}_{channel}_TRIGGER')
|
|
|
|
|
|
print('+++ tigger: ', var.trigger)
|
|
|
|
|
|
# TODO: 切通道逻辑 ,by csq
|
|
|
# 一个硬件保护功能，避免中间状态， type channel :1 2 -> 0 0 -> 2 5 避免 1 2 -> 2 3
|
|
|
var_type_oldvalue = self._read(var_type)
|
|
|
var_channel_oldvalue = self._read(var_channel)
|
|
|
if var_type_oldvalue != Type_Dic[
|
|
|
var.sig_type] and var_channel_oldvalue != in_or_out_value and var_type_oldvalue != 0 and var_channel_oldvalue != 0:
|
|
|
self._write(var_channel.uri, 0, var_channel.val_type)
|
|
|
self._write(var_type.uri, 0, var_type.val_type)
|
|
|
time.sleep(1)
|
|
|
|
|
|
# 跳变的时候只给跳变值
|
|
|
# TODO：如果在设置跳变值之前切了通道，此时channel为0，硬件不会输出。
|
|
|
if var.trigger:
|
|
|
self._write(var_trigger.uri, value, var_trigger.val_type)
|
|
|
# 除了置跳变，还需要把参考信号置为相应的值
|
|
|
sys_refer: PointModel = PointModel.get(PointModel.sig_name == f'__SYS.REFER_{var.trigger}')
|
|
|
# 得到是RPC(x) 从上面的字典里面取
|
|
|
# rpc_x = refer_list[(int(rpc[3:])) + 2 ** (int(channel) - 1) - 2]
|
|
|
rpc_x = refer_dic[f'{rpc}_{channel}']
|
|
|
|
|
|
self._write(sys_refer.uri, rpc_x, sys_refer.val_type)
|
|
|
# 否则就给起始值
|
|
|
else:
|
|
|
print('起始值： ', value)
|
|
|
# 先给类型再给通道比较好
|
|
|
self._write(var_type.uri, Type_Dic[var.sig_type], var_type.val_type)
|
|
|
self._write(var_channel.uri, in_or_out_value, var_channel.val_type)
|
|
|
self._write(var_start.uri, value, var_start.val_type)
|
|
|
|
|
|
# TODO：由于他会在发start信号之后把所有跳变都发出去，所以我们在初始的时候把所有跳变值都设置为起始值
|
|
|
self._write(var_trigger.uri, value, var_trigger.val_type)
|
|
|
|
|
|
elif 'ESFAC' in rpc.upper():
|
|
|
# TODO: 如果在其他通道被占用的情况下，需要先把该通道切到0，再切指定通道
|
|
|
for i in range(1, 6):
|
|
|
check_channel: PointModel = PointModel.get(PointModel.sig_name == f'{rpc}_{i}_CHANNEL')
|
|
|
v = self._read(check_channel)
|
|
|
# print('>>>v,channel,i:', v, channel,i)
|
|
|
if v == int(in_or_out_value) and int(channel) != i:
|
|
|
self._write(check_channel.uri, 0, check_channel.val_type)
|
|
|
|
|
|
var_channel: PointModel = PointModel.get(PointModel.sig_name == f'{rpc}_{channel}_CHANNEL')
|
|
|
self._write(var_channel.uri, in_or_out_value, var_channel.val_type)
|
|
|
elif var.sig_type == SigType.FREG:
|
|
|
return self._write(var.uri, value, var.val_type)
|
|
|
else:
|
|
|
raise exception.SkError(exception.UNSUPPORTED_TYPE,
|
|
|
f'{self.__class__.__name__} not support {var.sig_type}')
|
|
|
|
|
|
return value
|
|
|
|
|
|
def _write(self, uri, value, val_type):
|
|
|
if isinstance(val_type, str):
|
|
|
val_type = ValType[val_type.upper()]
|
|
|
try:
|
|
|
if val_type == ValType.B1:
|
|
|
value = int(value)
|
|
|
value = 1 if value > 0 else 0
|
|
|
elif val_type in (ValType.F32, ValType.D64):
|
|
|
value = float(value)
|
|
|
else:
|
|
|
value = int(value)
|
|
|
|
|
|
except (TypeError, ValueError):
|
|
|
raise exception.SkError(exception.VAR_CFG_ERROR, f'{uri} config error')
|
|
|
|
|
|
f_code, address, length = map(int, uri.split(':'))
|
|
|
print('>>+_+_+', address, value)
|
|
|
if f_code == cst.COILS:
|
|
|
value = 1 if int(value) > 0 else 0
|
|
|
self._cmd(f_code=cst.WRITE_SINGLE_COIL, address=address, output_value=value)
|
|
|
|
|
|
elif f_code == cst.HOLDING_REGISTERS:
|
|
|
if val_type == ValType.D64:
|
|
|
output_value = struct.unpack('<HHHH', struct.pack('<d', value))
|
|
|
elif val_type == ValType.U64:
|
|
|
output_value = struct.unpack('<HHHH', struct.pack('<Q', value))
|
|
|
elif val_type == ValType.U32:
|
|
|
output_value = struct.unpack('<HH', struct.pack('<L', value))
|
|
|
elif val_type == ValType.U16:
|
|
|
output_value = (value,)
|
|
|
else:
|
|
|
raise exception.SkError(exception.UNSUPPORTED_TYPE,
|
|
|
f'{self.__class__.__name__} not support {val_type}')
|
|
|
|
|
|
self._cmd(f_code=cst.WRITE_MULTIPLE_REGISTERS, address=address, output_value=output_value)
|
|
|
|
|
|
else:
|
|
|
raise exception.SkError(exception.READ_ONLY, f'{uri} is ReadOnly')
|
|
|
return value
|
|
|
|
|
|
def read(self, var: IVar) -> T_Val:
|
|
|
# 没有指定通道，无法设置，直接返回0
|
|
|
|
|
|
# if not var.channel and var.sig_type != SigType.FREG:
|
|
|
# raise exception.SkError(exception.VAR_CFG_ERROR, f'{var.name} 没有设置通道')
|
|
|
# return 0
|
|
|
|
|
|
# TODO:ESFAC专用，当发过来的channel不为空，既要设置，又要读
|
|
|
if var.sig_type == SigType.FREG:
|
|
|
# 把Val_type 转为ValModel.val_type
|
|
|
# var.val_type = var.val_type.name
|
|
|
return self._read(var)
|
|
|
else:
|
|
|
channel = var.channel
|
|
|
rpc, in_or_out = var.uri.split(':')
|
|
|
if re.search(r'(\d+)', in_or_out):
|
|
|
in_or_out_value = re.search(r'(\d+)', in_or_out).groups()[0]
|
|
|
in_or_out_value = int(in_or_out_value)
|
|
|
else:
|
|
|
raise exception.SkError(exception.UNSUPPORTED_TYPE,
|
|
|
f'{var.name} uri中没有(IN|OUT)的值 ')
|
|
|
|
|
|
# 有通道，就需要设置,设置好读状态
|
|
|
if rpc.startswith('ESFAC'):
|
|
|
# TODO: 如果在其他通道被占用的情况下，需要先把该通道切到0，再切指定通道
|
|
|
for i in range(1, 6):
|
|
|
check_channel: PointModel = PointModel.get(PointModel.sig_name == f'{rpc}_{i}_CHANNEL')
|
|
|
v = self._read(check_channel)
|
|
|
if v == int(in_or_out_value) and int(channel) != i:
|
|
|
self._write(check_channel.uri, 0, check_channel.val_type)
|
|
|
|
|
|
var_channel: PointModel = PointModel.get(PointModel.sig_name == f'{rpc}_{channel}_CHANNEL')
|
|
|
self._write(var_channel.uri, in_or_out_value, var_channel.val_type)
|
|
|
# 等待2s来让设置有用
|
|
|
time.sleep(2)
|
|
|
var_state: PointModel = PointModel.get(PointModel.sig_name == f'{rpc}_{channel}_STATE')
|
|
|
state = self._read(var_state)
|
|
|
return state
|
|
|
# rpc 直接检查状态，不需要切通道,只用于读取16个停堆信号，其他rpc不能读取状态和时间
|
|
|
else:
|
|
|
var_state: PointModel = PointModel.get(PointModel.sig_name == f'{rpc}_{in_or_out_value}_STATE')
|
|
|
state = self._read(var_state)
|
|
|
return state
|
|
|
|
|
|
def _read(self, var: IVar) -> T_Val:
|
|
|
if isinstance(var, PointModel):
|
|
|
val_type = ValType[var.val_type.upper()]
|
|
|
else:
|
|
|
val_type = var.val_type
|
|
|
|
|
|
try:
|
|
|
f_code, address, length = map(int, var.uri.split(':'))
|
|
|
except (TypeError, ValueError):
|
|
|
raise exception.SkError(exception.VAR_CFG_ERROR, f'{var} config error')
|
|
|
|
|
|
data = self._cmd(f_code=f_code, address=address, quantity_of_x=length)
|
|
|
if val_type == ValType.D64:
|
|
|
print('read value:', struct.unpack('<d', struct.pack('<HHHH', *data))[0])
|
|
|
return struct.unpack('<d', struct.pack('<HHHH', *data))[0]
|
|
|
elif val_type == ValType.B1:
|
|
|
return data[0]
|
|
|
elif val_type == ValType.U64:
|
|
|
return struct.unpack(f'<Q', struct.pack(f'<HHHH', *data))[0]
|
|
|
elif val_type == ValType.U16:
|
|
|
return data[0]
|
|
|
else:
|
|
|
raise exception.SkError(exception.UNSUPPORTED_TYPE,
|
|
|
f'{self.__class__.__name__} not support {val_type}')
|
|
|
|
|
|
def _cmd(self,
|
|
|
f_code: int,
|
|
|
address: int,
|
|
|
quantity_of_x: int = 0,
|
|
|
output_value: _T_OUTPUT_VALUE = 0,
|
|
|
expected_length: int = -1
|
|
|
) -> _T_OUTPUT_VALUE:
|
|
|
try:
|
|
|
return self.execute(
|
|
|
self._slave,
|
|
|
f_code,
|
|
|
address,
|
|
|
quantity_of_x=quantity_of_x,
|
|
|
output_value=output_value,
|
|
|
expected_length=expected_length
|
|
|
)
|
|
|
except (socket.timeout, ConnectionRefusedError, ConnectionResetError, OSError) as e:
|
|
|
raise exception.SkError(exception.NETWORK_ERROR, e)
|
|
|
except ModbusError as e:
|
|
|
raise exception.SkError(exception.PROTOCOL_ERROR, e)
|
|
|
|
|
|
def clear_channel_ai(self, now_channel):
|
|
|
'''
|
|
|
当多个AI时使用，避免多个通道都给ai值的情况发生
|
|
|
:return:
|
|
|
'''
|
|
|
for i in range(1, 5):
|
|
|
for j in range(1, 3):
|
|
|
var_channel = f'RPC{i}_{j}_CHANNEL'
|
|
|
var_type = f'RPC{i}_{j}_TYPE'
|
|
|
var_s_v = f'RPC{i}_{j}_START_VALUE'
|
|
|
iv_channel: PointModel = PointModel.get(PointModel.sig_name == var_channel)
|
|
|
iv_type: PointModel = PointModel.get(PointModel.sig_name == var_type)
|
|
|
iv_s_value: PointModel = PointModel.get(PointModel.sig_name == var_s_v)
|
|
|
v_ty = self._read(iv_type)
|
|
|
if now_channel == var_channel or v_ty != 1:
|
|
|
continue
|
|
|
|
|
|
v = self._read(iv_channel)
|
|
|
if v != 0:
|
|
|
self._write(iv_s_value.uri, 0, iv_s_value.val_type)
|
|
|
self._write(iv_type.uri, 3, iv_type.val_type)
|
|
|
self._write(iv_channel.uri, 0, iv_channel.val_type)
|
|
|
|
|
|
|
|
|
class TXS_Dev(IDev):
|
|
|
def __int__(self):
|
|
|
IDev.__init__(self)
|
|
|
|
|
|
def setup(self, uri):
|
|
|
host, port = uri.split(':')
|
|
|
self._url = host
|
|
|
self._port = port
|
|
|
# self.socket_client.listen(5)
|
|
|
|
|
|
def read(self, var: IVar):
|
|
|
if var.group:
|
|
|
|
|
|
# 只有M1,只读一个
|
|
|
if len(list(filter(lambda x: x.channel == 'M2', var.group))) <= 0:
|
|
|
# 对点专用
|
|
|
if var.txs_port:
|
|
|
var.group[0].txs_port = var.txs_port
|
|
|
return self._read(var.group[0])
|
|
|
|
|
|
# 用于比较读到的值是否相同
|
|
|
value_list = []
|
|
|
# 当有多个点时，返回所有M2点的值，再进行比较
|
|
|
for iv in var.group:
|
|
|
# 对点专用
|
|
|
if var.txs_port:
|
|
|
iv.txs_port = var.txs_port
|
|
|
|
|
|
if iv.channel == 'M2':
|
|
|
value_list.append(self._read(iv))
|
|
|
|
|
|
# 匹配该点的所有拓展名下的M2的值，如果不相同就报错，相同就返回
|
|
|
value_list_final = value_list[0]
|
|
|
for v in value_list:
|
|
|
if value_list_final != v:
|
|
|
raise exception.SkError(f'{var.name}的所有拓展名下的M2值不相同')
|
|
|
|
|
|
return value_list_final
|
|
|
|
|
|
return self._read(var)
|
|
|
|
|
|
def write(self, var: IVar, value: T_Val):
|
|
|
# 带proc_val使用，会取到一系列的点
|
|
|
if var.group:
|
|
|
all_is_m1 = True
|
|
|
# 只有M1,只读一个
|
|
|
if len(list(filter(lambda x: x.channel == 'M2', var.group))) > 0:
|
|
|
all_is_m1 = False
|
|
|
|
|
|
for iv in var.group:
|
|
|
# 只设置 M1,这个时候给值就行,通常是取消强制
|
|
|
if len(var.group) == 1:
|
|
|
return self._write(iv, value)
|
|
|
|
|
|
# 'M2'
|
|
|
if iv.channel == 'M2':
|
|
|
self._write(iv, value)
|
|
|
# 都是'M1'
|
|
|
if iv.channel == 'M1':
|
|
|
if all_is_m1:
|
|
|
self._write(iv, value)
|
|
|
# 有M2，M1置为1
|
|
|
else:
|
|
|
self._write(iv, 1)
|
|
|
|
|
|
if all_is_m1:
|
|
|
return int(value)
|
|
|
else:
|
|
|
return float(value)
|
|
|
|
|
|
# 这种情况是直接赋值单点，不带proc_val的时候使用
|
|
|
else:
|
|
|
return self._write(var, value)
|
|
|
|
|
|
def _read(self, var: IVar):
|
|
|
try:
|
|
|
print((self._url, int(self._port)))
|
|
|
socket_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
|
socket_client.connect((self._url, int(self._port)))
|
|
|
except Exception:
|
|
|
raise exception.SkError(f'与远程主机{self._url}:{self._port}通信被拒绝')
|
|
|
return
|
|
|
diagram, block, parameter, cpuid = var.uri.split(':')
|
|
|
if cpuid:
|
|
|
data = {
|
|
|
'message': 'read_cpu',
|
|
|
'diagram': diagram,
|
|
|
'block': block,
|
|
|
'parameter': parameter,
|
|
|
'cpuid': cpuid,
|
|
|
}
|
|
|
else:
|
|
|
data = {
|
|
|
'message': 'read',
|
|
|
'diagram': diagram,
|
|
|
'block': block,
|
|
|
'parameter': parameter,
|
|
|
}
|
|
|
|
|
|
# 当硬件给值的时候M2不会跟着硬件改变，需要检查port
|
|
|
# cpuid.port("diagram","block","AO1").value().v
|
|
|
if var.txs_port:
|
|
|
data['message'] = 'read_port'
|
|
|
|
|
|
data = json.dumps(data).encode()
|
|
|
# size = str(len(data)).encode()
|
|
|
# print(size)
|
|
|
# socket_client.send(size)
|
|
|
socket_client.send(data)
|
|
|
response = socket_client.recv(1024)
|
|
|
# print(response)
|
|
|
response = json.loads(response.decode())
|
|
|
LOGGER.error('+++', response)
|
|
|
if response['message'] == 'OK':
|
|
|
# socket_client.close()
|
|
|
return response['value']
|
|
|
else:
|
|
|
raise exception.SkError(exception.NETWORK_ERROR, f'TXS remote error, {var}, response={response}')
|
|
|
|
|
|
def _write(self, var: IVar, value: T_Val):
|
|
|
try:
|
|
|
socket_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
|
socket_client.connect((self._url, int(self._port)))
|
|
|
except Exception:
|
|
|
raise exception.SkError(f'与远程主机{self._url}:{self._port}通信被拒绝')
|
|
|
# return False
|
|
|
|
|
|
diagram, block, parameter, cpuid = var.uri.split(':')
|
|
|
try:
|
|
|
if var.val_type == ValType.B1:
|
|
|
value = int(value)
|
|
|
value = 1 if value > 0 else 0
|
|
|
elif var.val_type == ValType.D64:
|
|
|
value = float(value)
|
|
|
else:
|
|
|
value = int(value)
|
|
|
except (TypeError, ValueError):
|
|
|
raise exception.SkError(exception.VAR_CFG_ERROR, f'{var} config error')
|
|
|
|
|
|
data = {
|
|
|
'message': 'write_cpu',
|
|
|
'diagram': diagram,
|
|
|
'block': block,
|
|
|
'parameter': parameter,
|
|
|
'cpuid': cpuid,
|
|
|
'value': value,
|
|
|
'type': var.val_type.name,
|
|
|
}
|
|
|
|
|
|
data = json.dumps(data).encode()
|
|
|
# size = str(len(data)).encode()
|
|
|
# print(size)
|
|
|
# socket_client.send(size)
|
|
|
socket_client.send(data)
|
|
|
|
|
|
response = socket_client.recv(1024)
|
|
|
response = json.loads(response.decode())
|
|
|
|
|
|
if response['message'] == 'OK':
|
|
|
return value
|
|
|
else:
|
|
|
raise exception.SkError(exception.VAR_CFG_ERROR, f'Network error {var} not found response:{response}')
|
|
|
return False
|
|
|
|
|
|
# socket_client.close()
|
|
|
|
|
|
|
|
|
class TxsPy(object):
|
|
|
"""
|
|
|
Txs 初始化脚本解释器
|
|
|
"""
|
|
|
|
|
|
def __init__(self):
|
|
|
self.source = None
|
|
|
self.ast = None
|
|
|
|
|
|
@classmethod
|
|
|
def compile(cls, source):
|
|
|
module = ast.parse(source)
|
|
|
|
|
|
self = TxsPy()
|
|
|
self.source = source
|
|
|
self.ast = module
|
|
|
return self
|
|
|
|
|
|
def execute(self, sw):
|
|
|
for exp in self.ast.body:
|
|
|
if isinstance(exp, (ast.ImportFrom, ast.Import)):
|
|
|
continue
|
|
|
|
|
|
if isinstance(exp, ast.Expr):
|
|
|
try:
|
|
|
self.__case_exp(exp, sw)
|
|
|
except Exception as e:
|
|
|
print(e, exp)
|
|
|
continue
|
|
|
|
|
|
def __case_exp(self, exp, sw):
|
|
|
value = exp.value
|
|
|
|
|
|
# cpu1111.memory("XRRP111SI103","ASIG001","M1").setValue(1)
|
|
|
if isinstance(value, ast.Call):
|
|
|
func = value.func
|
|
|
if func.attr == 'setValue':
|
|
|
args = func.value.args
|
|
|
m_func = func.value.func
|
|
|
if m_func.attr == 'memory':
|
|
|
key, ext, flag = args
|
|
|
key = key.s
|
|
|
ext = ext.s
|
|
|
flag = flag.s
|
|
|
cpu = m_func.value.id
|
|
|
val = value.args[0].n
|
|
|
# 这里有个问题，就是很多点不存在我们的数据库里
|
|
|
# txs_uri = f'{key}:{ext}:{flag}:{cpu}'
|
|
|
# txs_var = VarModel.filter(VarModel.uri == txs_uri)
|
|
|
# if not txs_var:
|
|
|
# LOGGER.error(f'Find Txs By uri={txs_uri} failed')
|
|
|
# return
|
|
|
# txs_var = txs_var.first()
|
|
|
# print('txs_var>>>', txs_var)
|
|
|
# sw.write(txs_var.sig_name, value=f'{val}(TX)')
|
|
|
|
|
|
# 临时解决方法，直接把语句发过去
|
|
|
script = f'{cpu}.memory("{key}","{ext}","{flag}").setValue({val})'
|
|
|
self.write(script)
|
|
|
return
|
|
|
elif func.attr == 'sleep':
|
|
|
val = value.args[0].n
|
|
|
time.sleep(val)
|
|
|
|
|
|
def write(self, script):
|
|
|
try:
|
|
|
socket_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
|
socket_client.connect(('192.168.20.5', 19513))
|
|
|
except Exception:
|
|
|
raise exception.SkError(f'与远程主机{self._url}:{self._port}通信被拒绝')
|
|
|
# return False
|
|
|
|
|
|
data = {
|
|
|
'message': 'exec_python',
|
|
|
'script': script,
|
|
|
}
|
|
|
|
|
|
data = json.dumps(data).encode()
|
|
|
# size = str(len(data)).encode()
|
|
|
# print(size)
|
|
|
# socket_client.send(size)
|
|
|
socket_client.send(data)
|
|
|
|
|
|
response = socket_client.recv(1024)
|
|
|
response = json.loads(response.decode())
|
|
|
|
|
|
print(response)
|
|
|
if response['message'] == 'OK':
|
|
|
return True
|
|
|
else:
|
|
|
raise exception.SkError(exception.VAR_CFG_ERROR, f'Network error {script} execute error:{response}')
|
|
|
return False
|