def update(data):
try:
db.save(data[0], data[1], data[2])
except Exception as ex:
db = RedisLua()
def __init__(self):
""" init """
self.connected = 0
self.closed = 0
self.socket_status = UNKNOWN
self.i = 0
self.retry = 0
self.last_errno = 0
self.db = RedisLua()
self.equipment_id = conf["equipment_id"]
self.open()
def __init__(self):
self.connected = 0
self.closed = 0
self.i = 0
self.retry = 0
self.last_errno = 0
self.db = RedisLua()
self.equipment_id = conf["equipment_id"]
self.tags = conf["TAGS"]
self.group = conf["GROUP"]
def __init__(self):
""" init """
self.connected = 0
self.closed = 0
self.socket_status = UNKNOWN
self.i = 0
self.retry = 0
self.last_errno = 0
self.db = RedisLua()
self.equipment_id = conf["equipment_id"]
self.open()
conf = get_config(conf_fn)["app"]
#conf = LoadConfig("config.toml").config
def supress(v, w):
#v[0],v[1],
#print v
if v[2] < w / 2 and v[2] > 20: # and v[0] - v[2] >0 and v[1] - v[2]>0 :
return True
rclient = RedisLua()
def save(x, y, r):
key = conf["redis_key"]
if r > 0:
data = 1
result = conf["equipment_id"]
rclient.save(key, result, data)
else:
pass
from config import get_config
#pythoncom.CoInitialize()
#opc_client = OpenOPC.client("Graybox.OPC.DAWrapper", "127.0.0.1")
#conf_fn = os.sep.join(
# [os.path.split(os.path.realpath(__file__))[0], "config.toml"])
conf_fn = "config.toml"
conf = get_config(conf_fn)["app"]
#print conf
db = RedisLua()
def update(data):
try:
db.save(data[0], data[1], data[2])
except Exception as ex:
db = RedisLua()
#print data
def main():
def __init__(self):
self.connected = 0
self.closed = 0
self.db = RedisLua()
class DBMonitor(object):
def __init__(self):
self.connected = 0
self.closed = 0
self.db = RedisLua()
def connect(self):
logging.debug("connect db...")
try:
self.mypool = pool.QueuePool(getconn, \
max_overflow=conf["db"]["max_overflow"], \
pool_size=conf["db"]["pool_size"])
# get a connection
self.conn = self.mypool.connect()
# use it
self.cursor = self.conn.cursor()
self.connected = 1
except Exception as ex:
self.connected = 0
def check_conn(self):
if self.connected == 0:
self.connect()
if self.connected == 0:
return 0
else:
self.connected = 1
return 1
def query(self):
"""
check db
"""
sql = conf["db"]["sql"]# """select * FROM [msdb].[dbo].[backupfile]"""
rows = self.cursor.execute(sql)
row = rows.fetchone()
logging.debug(row[0])
self.process(row)
#print(row)
"""
for i in x:
print i[0],i[1],i[2]
"""
def process(self, row):
""" save query value to redis (lus script)
if EInit < now and ETest == None and status = 'start':
data = 1
elif EInit < now and ETest < Now and status in ['finished', 'cancel']
data = 2
"""
#print (row)
key = conf["equipment_id"]
result = "test start"
result = "test end"
data = 1 ## 1
self.db.save(key, result, data)
def __del__(self):
"""
release db connection to pool
"""
self.cursor.close()
del self.cursor
self.conn.close()
class AKClient(object):
"""
AK Protocol Test,
* BEP/Burke E. Porter
* MAHA
* Horiba
* AVL
"""
def __init__(self):
""" init """
self.connected = 0
self.closed = 0
self.socket_status = UNKNOWN
self.i = 0
self.retry = 0
self.last_errno = 0
self.db = RedisLua()
self.equipment_id = conf["equipment_id"]
self.open()
def open(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket_status = SOCKET_OPENED
def connect(self):
""" connect """
try:
#logger.debug("connecting...")
if self.closed == 0:
self.sock.connect((conf["host"], conf["port"]))
else:
# open a socket
#self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.open()
self.sock.connect((conf["host"], conf["port"]))
self.closed = 0
self.connected = 1
self.socket_status = SOCKET_CONNECTED
except Exception as ex:
#logger.debug(traceback.format_exc())
if self.last_errno == ex.errno:
#logger.debug("[Errno %s]" %(ex.errno))
pass
else:
self.last_errno = ex.errno
#logger.debug(ex)
self.connected = 0
#self.sock = None
def close(self):
""" close socket """
try:
self.sock.close()
self.closed = 1
self.socket_status = SOCKET_CLOSED
except Exception as ex:
#logger.debug(ex)
#logger.debug("closed?")
pass
def pack(self, cmd):
""" pack """
#cmd = "AVFI"
clen = len(cmd)
# AK Command telegram
fmt = "!2b%ds5b" % (clen)
#print fmt
buf = struct.pack(fmt, STX, BLANK, cmd, BLANK, K, conf["channel_number"], BLANK, ETX)
#logger.debug(buf)
return buf
def send(self, buf):
""" send """
try:
self.sock.sendall(buf)
except Exception as ex:
#logger.debug(ex)
raise(Exception(ex))
def parse(self, val):
""" process received data """
#logger.debug("parse: %s" % (val) )
try:
#print val[2].lower()
func = getattr(aklib, val[2].lower())
length = len(val)
message = val[length-2]
#logger.debug(result)
value = func(message.strip())
#print data
#logger.debug("====== data ======[%s]" %(length))
#logger.debug(data)
# redis key, value
self.db.save(self.equipment_id, value, message)
except Exception as ex:
#logger.debug(ex)
#'module' object has no attribute 'abcd'
raise Exception("no parser")
def recv(self):
""" recv """
try:
data = self.sock.recv(1024)
except Exception as ex:
#logger.debug(ex)
raise(Exception(ex))
#logger.debug( data )
#print "data:%s:" %(data)
#return 0
dlen = len(data) - conf["non_data_len"]#10
if dlen < 0:
#raise Exception("struct error")
fmt = "!2b4s3b"
else:
# AK Response telegram
fmt = "!2b4s3b%ds1b" % (dlen)
try:
val = struct.unpack(fmt, data)
#logger.debug(val)
self.parse(val)
except Exception as ex:
#logger.debug("fmt:[%s]" % (fmt))
#logger.debug(traceback.format_exc())
#logger.error(ex)
pass
#print(val)
#msg = "Cmd:[%s],Error:[%s], Data:[%s]" % (val[2], val[4], val[6])
#logger.debug ( msg )
#cmd = val[2]
#return cmd
#print val
#print repr(val)
def get_data(self, cmd):
try:
buf = self.pack(cmd)
# send
self.send(buf)
# receive [block]
self.recv()
except Exception as ex:
#logger.debug(ex)
self.close()
#print ex
#ak_client.connect()
self.connected = 0
def check_conn(self):
#logger.debug(self.connected)
if self.connected == 0:
self.connect()
if self.connected == 0:
return 0
else:
self.connected = 1
return 1
def cb(self):
if self.connected == 0:
if self.retry < conf["max_retry"]:
self.connect()
else:
raise (Exception("break"))
if self.sock == None:
self.retry = self.retry + 1
raise (Exception("continue"))
else:
self.connected = 1
self.retry = 0
self.i = self.i+1
if self.i > 20:
self.i = 1
def run(self):
""" run """
i = 0
while 1:
self.check_conn()
if self.connected == 0:
# sleep
gevent.sleep(conf["reconnection_interval"])
else:
#cmd = "AVFI"
#cmd = "AWEG"
#cmd = "AWRT"
cmds = conf["cmds"] #["ASTF", "ASTZ", "AWRT"]
try:
if i<len(cmds):
cmd = cmds[i]
#logger.debug("cmd>:%s" %(cmd) )
i = i +1
self.get_data(cmd)
# sleep
gevent.sleep(conf["ticker_interval"])
else:
i = 0
#cmd = cmds[i]
except Exception as ex:
logger.debug(ex)
def __init__(self):
self.connected = 0
self.closed = 0
self.db = RedisLua()
class DBMonitor(object):
def __init__(self):
self.connected = 0
self.closed = 0
self.db = RedisLua()
def connect(self):
logging.debug("connect db...")
try:
self.mypool = pool.QueuePool(getconn, \
max_overflow=conf["db"]["max_overflow"], \
pool_size=conf["db"]["pool_size"])
# get a connection
self.conn = self.mypool.connect()
# use it
self.cursor = self.conn.cursor()
self.connected = 1
except Exception as ex:
self.connected = 0
def check_conn(self):
if self.connected == 0:
self.connect()
if self.connected == 0:
return 0
else:
self.connected = 1
return 1
def query(self):
"""
check db
"""
sql = conf["db"][
"sql"] # """select * FROM [msdb].[dbo].[backupfile]"""
rows = self.cursor.execute(sql)
row = rows.fetchone()
logging.debug(row[0])
self.process(row)
#print(row)
"""
for i in x:
print i[0],i[1],i[2]
"""
def process(self, row):
""" save query value to redis (lus script)
if EInit < now and ETest == None and status = 'start':
data = 1
elif EInit < now and ETest < Now and status in ['finished', 'cancel']
data = 2
"""
#print (row)
key = conf["equipment_id"]
result = "test start"
result = "test end"
data = 1 ## 1
self.db.save(key, result, data)
def __del__(self):
"""
release db connection to pool
"""
self.cursor.close()
del self.cursor
self.conn.close()
class AKClient(object):
"""
AK Protocol Test,
* BEP/Burke E. Porter
* MAHA
* Horiba
* AVL
"""
def __init__(self):
""" init """
self.connected = 0
self.closed = 0
self.socket_status = UNKNOWN
self.i = 0
self.retry = 0
self.last_errno = 0
self.db = RedisLua()
self.equipment_id = conf["equipment_id"]
self.open()
def open(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket_status = SOCKET_OPENED
def connect(self):
""" connect """
try:
#logger.debug("connecting...")
if self.closed == 0:
self.sock.connect((conf["host"], conf["port"]))
else:
# open a socket
#self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.open()
self.sock.connect((conf["host"], conf["port"]))
self.closed = 0
self.connected = 1
self.socket_status = SOCKET_CONNECTED
except Exception as ex:
#logger.debug(traceback.format_exc())
if self.last_errno == ex.errno:
#logger.debug("[Errno %s]" %(ex.errno))
pass
else:
self.last_errno = ex.errno
#logger.debug(ex)
self.connected = 0
#self.sock = None
def close(self):
""" close socket """
try:
self.sock.close()
self.closed = 1
self.socket_status = SOCKET_CLOSED
except Exception as ex:
#logger.debug(ex)
#logger.debug("closed?")
pass
def pack(self, cmd):
""" pack """
#cmd = "AVFI"
clen = len(cmd)
# AK Command telegram
fmt = "!2b%ds5b" % (clen)
#print fmt
buf = struct.pack(fmt, STX, BLANK, cmd, BLANK, K,
conf["channel_number"], BLANK, ETX)
#logger.debug(buf)
return buf
def send(self, buf):
""" send """
try:
self.sock.sendall(buf)
except Exception as ex:
#logger.debug(ex)
raise (Exception(ex))
def parse(self, val):
""" process received data """
#logger.debug("parse: %s" % (val) )
try:
#print val[2].lower()
func = getattr(aklib, val[2].lower())
length = len(val)
message = val[length - 2]
#logger.debug(result)
value = func(message.strip())
#print data
#logger.debug("====== data ======[%s]" %(length))
#logger.debug(data)
# redis key, value
self.db.save(self.equipment_id, value, message)
except Exception as ex:
#logger.debug(ex)
#'module' object has no attribute 'abcd'
raise Exception("no parser")
def recv(self):
""" recv """
try:
data = self.sock.recv(1024)
except Exception as ex:
#logger.debug(ex)
raise (Exception(ex))
#logger.debug( data )
#print "data:%s:" %(data)
#return 0
dlen = len(data) - conf["non_data_len"] #10
if dlen < 0:
#raise Exception("struct error")
fmt = "!2b4s3b"
else:
# AK Response telegram
fmt = "!2b4s3b%ds1b" % (dlen)
try:
val = struct.unpack(fmt, data)
#logger.debug(val)
self.parse(val)
except Exception as ex:
#logger.debug("fmt:[%s]" % (fmt))
#logger.debug(traceback.format_exc())
#logger.error(ex)
pass
#print(val)
#msg = "Cmd:[%s],Error:[%s], Data:[%s]" % (val[2], val[4], val[6])
#logger.debug ( msg )
#cmd = val[2]
#return cmd
#print val
#print repr(val)
def get_data(self, cmd):
try:
buf = self.pack(cmd)
# send
self.send(buf)
# receive [block]
self.recv()
except Exception as ex:
#logger.debug(ex)
self.close()
#print ex
#ak_client.connect()
self.connected = 0
def check_conn(self):
#logger.debug(self.connected)
if self.connected == 0:
self.connect()
if self.connected == 0:
return 0
else:
self.connected = 1
return 1
def cb(self):
if self.connected == 0:
if self.retry < conf["max_retry"]:
self.connect()
else:
raise (Exception("break"))
if self.sock == None:
self.retry = self.retry + 1
raise (Exception("continue"))
else:
self.connected = 1
self.retry = 0
self.i = self.i + 1
if self.i > 20:
self.i = 1
def run(self):
""" run """
i = 0
while 1:
self.check_conn()
if self.connected == 0:
# sleep
gevent.sleep(conf["reconnection_interval"])
else:
#cmd = "AVFI"
#cmd = "AWEG"
#cmd = "AWRT"
cmds = conf["cmds"] #["ASTF", "ASTZ", "AWRT"]
try:
if i < len(cmds):
cmd = cmds[i]
#logger.debug("cmd>:%s" %(cmd) )
i = i + 1
self.get_data(cmd)
# sleep
gevent.sleep(conf["ticker_interval"])
else:
i = 0
#cmd = cmds[i]
except Exception as ex:
logger.debug(ex)
class OPCMonitor(object):
def __init__(self):
self.connected = 0
self.closed = 0
self.i = 0
self.retry = 0
self.last_errno = 0
self.db = RedisLua()
self.equipment_id = conf["equipment_id"]
self.tags = conf["TAGS"]
self.group = conf["GROUP"]
def connect(self):
logger.debug("connect...............")
try:
if conf["Use_Wrapper"] == True:
logger.debug(conf["DAWrapper"])
self.opc_client = OpenOPC.client(conf["DAWrapper"], conf["HOST"])
else:
logger.debug(conf["PROVIDER"])
self.opc_client = OpenOPC.open_client(conf["HOST"], conf["PORT"])
self.opc_client.connect(conf["PROVIDER"], conf["OPC_HOST"])
self.connected = 1
except Exception as ex:
logger.debug(ex)
self.connected = 0
def check_conn(self):
#logger.debug(self.connected)
if self.connected == 0:
self.connect()
if self.connected == 0:
return 0
else:
self.connected = 1
return 1
def check(self):
try:
data = self.opc_client.read(tags = self.tags, group=self.group, update=100)
tag_val = data[0][1]
except Exception as ex:
tag_val = False
if tag_val == True:
val = 1
else:
val = 0
self.post(val)
def post(self, val):
key = self.equipment_id
result = ""
logger.debug("%s,%s" % (key, val))
ttl = 2 *conf["INTERVAL"]
rtn = self.db.save(key, result, 1, ttl)