def start(self):
self.log.trace()
self.__flag = Wrapper.Event()
self.__job = Wrapper.Thread(
group=None,
target=self.__loop,
name=None,
kwargs={"stop_event": self.__flag})
self.__job.daemon = True
self.__flag.set()
self.__job.start()
def __init__(self, handle=None):
matrix = {
EventId.CONNECTREQ: {
self.__StateId.INIT: self.__init_connectreq,
self.__StateId.CONNECTED: self.__connected_connectreq
},
EventId.CONNECTCNF: {
self.__StateId.INIT: self.__init_connectcnf,
self.__StateId.CONNECTED: self.__connected_connectcnf
},
EventId.SENDCNF: {
self.__StateId.INIT: self.__init_sendcnf,
self.__StateId.CONNECTED: self.__connected_sendcnf
},
EventId.DATANOTIFY: {
self.__StateId.INIT: self.__init_datanotify,
self.__StateId.CONNECTED: self.__connected_datanotify
},
EventId.DISCONNECTREQ: {
self.__StateId.INIT: self.__init_disconnectreq,
self.__StateId.CONNECTED: self.__connected_disconnectreq
},
EventId.DISCONNECTCNF: {
self.__StateId.INIT: self.__init_disconnectcnf,
self.__StateId.CONNECTED: self.__connected_disconnectcnf
}
}
MultiThreadClass.__init__(self,
name=__name__,
uniid=UnitId.UNITCTRL,
matrix=matrix,
daemon=False)
self.__handle = handle
self.__sync = {
"lock": Wrapper.Lock(),
"event": {
"connect": Wrapper.Event(),
"disconnect": Wrapper.Event()
}
}
common_daemon_flug = False
self.__session_mng = SessionMng(daemon=common_daemon_flug)
self.__socket_ctrl = SocketCtrl(daemon=common_daemon_flug)
self.__http_ctrl = HttpCtrl(daemon=common_daemon_flug)
self.__parse_info = ParseInfo(daemon=common_daemon_flug)
self.__timer_mng = TimerMng(daemon=common_daemon_flug)
self.state = self.__StateId.INIT
def __init__(self, daemon=False):
matrix = {
EventId.SOCKETCONNECTREQ: {
self.__StateId.IDLE: self.__idle_socketconnectreq,
self.__StateId.RECEIVING: self.__receiving_socketconnectreq},
EventId.SOCKETSENDREQ: {
self.__StateId.IDLE: self.__idle_socketsendreq,
self.__StateId.RECEIVING: self.__receiving_socketsendreq},
EventId.SOCKETDISCONNECTREQ: {
self.__StateId.IDLE: self.__idle_socketdisconnectreq,
self.__StateId.RECEIVING: self.__receiving_socketdisconnectreq}}
MultiThreadClass.__init__(
self,
name=__name__,
uniid=UnitId.SOCKETCTRL,
matrix=matrix,
daemon=daemon)
self.__socket_info = dict()
self.__main_socket = None
self.__socket = None
self.__bufsize = 2048
self.__flag_loop = None
self.__job_loop = None
self.__lock = Wrapper.Lock()
self.state = self.__StateId.IDLE
def __get_response(self, url):
self.log.trace()
self.log.info("open URL %s", url)
response = self.__openerDirector.open(url)
data = Wrapper.decode(response.read())
self.log.info("response data %s", data)
response.close()
return data
def send(self, data):
self.log.trace()
sendData = Wrapper.encode(data + "\0")
dataByte = len(sendData)
sendByte = self.__socket.send(sendData)
if dataByte == sendByte:
return True
else:
return False
def recv(self):
"""
TODO
受信したデータはstr型
len()でバイト数が0なら受診なしとみなしてNoneを返すようにする。
len('\0') = 1 になるため、受信データ = '\0' の場合にNoneを返す。
呼び出し元はNoneなら受信なしとして、ソケットがクローズされたものとみなす。
"""
self.log.trace()
data = self.__socket.recv(self.bufsize)
unidata = Wrapper.decode(data)
unidata = unidata.replace("\0", "")
return unidata
def __idle_timerreq(self, container):
self.log.trace()
self.__timer_list_lock.acquire(blocking = True, timeout = -1)
timer_id = Unique.unique()
timer = Wrapper.Timer(
interval = container.message.interval,
function = self.__timer_expire,
args = None,
kwargs = {
"timer_id": timer_id,
"unit_id": container.message.unit_id,
"event_id": container.message.event_id,
"data": container.message.data})
self.__timer_list[timer_id] = timer
self.__timer_list[timer_id].start()
self.__timer_list_lock.release()
return True
def __init__(self, daemon=False):
self.__STATE_IDLE = 0x00
matrix = {
EventId.TIMERREQ: {
self.__STATE_IDLE: self.__idle_timerreq}}
MultiThreadClass.__init__(
self,
name=__name__,
uniid=UnitId.TIMERMNG,
matrix=matrix,
daemon=daemon)
self.state = self.__STATE_IDLE
self.__timer_list = dict()
self.__timer_list_lock = Wrapper.Lock()