X-Git-Url: https://git.realraum.at/?p=svn42.git;a=blobdiff_plain;f=track-presence.py;h=3877c5c7aa1543191c506b084e95cb6fd0c8cb46;hp=587b3c995de7e8042ed7ac757091514494760127;hb=a34e51d757fe52cb19de2937ae1b211894167524;hpb=d9c593164060ccbad7442c0616b8338b5947ca32 diff --git a/track-presence.py b/track-presence.py old mode 100644 new mode 100755 index 587b3c9..3877c5c --- a/track-presence.py +++ b/track-presence.py @@ -41,17 +41,20 @@ class UWSConfig: self.config_parser.add_section('door') self.config_parser.set('door','cmd_socket',"/var/run/tuer/door_cmd.socket") self.config_parser.add_section('sensors') - self.config_parser.set('sensors','remote_cmd',"ssh -i /flash/tuer/id_rsa -o PasswordAuthentication=no %RHOST% %RSHELL% %RSOCKET%") + self.config_parser.set('sensors','remote_cmd',"ssh -i /flash/tuer/id_rsa -o PasswordAuthentication=no -o StrictHostKeyChecking=no %RHOST% %RSHELL% %RSOCKET%") self.config_parser.set('sensors','remote_host',"root@slug.realraum.at") self.config_parser.set('sensors','remote_socket',"/var/run/powersensordaemon/cmd.sock") self.config_parser.set('sensors','remote_shell',"usocket") self.config_parser.add_section('tracker') - self.config_parser.set('tracker','sec_wait_movement_after_door_closed',2.5) - self.config_parser.set('tracker','sec_general_movement_timeout',3600) + self.config_parser.set('tracker','sec_wait_after_close_using_cardphone',"4.2") + self.config_parser.set('tracker','sec_wait_for_movement_before_warning',"60") + self.config_parser.set('tracker','sec_wait_after_close_using_manualswitch',"22.0") + self.config_parser.set('tracker','sec_movement_before_manual_switch',"-3.0") #neg duration means: movement has to occur _after_ door was closed manually + self.config_parser.set('tracker','sec_general_movement_timeout',"3600") + self.config_parser.set('tracker','num_movements_req_on_nonpresence_until_present',"3") self.config_parser.set('tracker','server_socket',"/var/run/tuer/presence.socket") - self.config_parser.set('tracker','photo_flashlight',950) - self.config_parser.set('tracker','photo_daylight',500) - self.config_parser.set('tracker','photo_artif_light',150) + self.config_parser.set('tracker','photo_flashlight',"1020") + self.config_parser.set('tracker','photo_artif_light',"970") self.config_parser.add_section('debug') self.config_parser.set('debug','enabled',"False") self.config_mtime=0 @@ -65,11 +68,10 @@ class UWSConfig: self.checkConfigUpdates() def guardReading(self): - self.lock.acquire() - while self.currently_writing: - self.finished_writing.wait() - self.currently_reading+=1 - self.lock.release() + with self.lock: + while self.currently_writing: + self.finished_writing.wait() + self.currently_reading+=1 def unguardReading(self): with self.lock: @@ -143,14 +145,17 @@ class UWSConfig: ######## Status Listener Threads ############ +threads_running=True def trackSensorStatusThread(uwscfg,status_tracker,connection_listener): + global sshp, threads_running #RE_TEMP = re.compile(r'temp\d: (\d+\.\d+)') - RE_PHOTO = re.compile(r'photo\d: .*(\d+)') - RE_MOVEMENT = re.compile(r'movement|button\d?|PanicButton') - RE_ERROR = re.compile(r'Error: (.+)') - while True: + RE_PHOTO = re.compile(r'photo\d: [^0-9]*?(\d+)',re.I) + RE_MOVEMENT = re.compile(r'movement|button\d?|PanicButton',re.I) + RE_ERROR = re.compile(r'Error: (.+)',re.I) + while threads_running: uwscfg.checkConfigUpdates() + sshp = None try: cmd = uwscfg.sensors_remote_cmd.replace("%RHOST%",uwscfg.sensors_remote_host).replace("%RSHELL%",uwscfg.sensors_remote_shell).replace("%RSOCKET%",uwscfg.sensors_remote_socket).split(" ") logging.debug("trackSensorStatusThread: Executing: "+" ".join(cmd)) @@ -159,26 +164,30 @@ def trackSensorStatusThread(uwscfg,status_tracker,connection_listener): if not sshp.poll() is None: raise Exception("trackSensorStatusThread: subprocess %d not started ?, returncode: %d" % (sshp.pid,sshp.returncode)) #sshp.stdin.write("listen movement\nlisten button\nlisten sensor\n") - logging.debug("trackSensorStatusThread: send: listen all") - sshp.stdin.write("listen all\n") + time.sleep(5) #if we send listen bevor usocket is running, we will never get output + #sshp.stdin.write("listen all\n") + logging.debug("trackSensorStatusThread: send: listen movement, etc") sshp.stdin.write("listen movement\n") sshp.stdin.write("listen button\n") sshp.stdin.write("listen sensor\n") - while True: + #sshp.stdin.write("sample temp0\n") + sshp.stdin.flush() + while threads_running: if not sshp.poll() is None: raise Exception("trackSensorStatusThread: subprocess %d finished, returncode: %d" % (sshp.pid,sshp.returncode)) line = sshp.stdout.readline() - logging.debug("trackSensorStatusThread:Got Line: " + line) if len(line) < 1: raise Exception("EOF on Subprocess, daemon seems to have quit, returncode: %d",sshp.returncode) - connection_listener.distributeData(line) + logging.debug("trackSensorStatusThread: Got Line: " + line) + if not line.startswith("Warning: Permanently added"): + connection_listener.distributeData(line) m = RE_MOVEMENT.match(line) if not m is None: status_tracker.movementDetected() continue m = RE_PHOTO.match(line) if not m is None: - status_tracker.currentLightLevel(m.group(1)) + status_tracker.currentLightLevel(int(m.group(1))) continue m = RE_ERROR.match(line) if not m is None: @@ -186,7 +195,7 @@ def trackSensorStatusThread(uwscfg,status_tracker,connection_listener): except Exception, ex: logging.error("trackSensorStatusThread: "+str(ex)) traceback.print_exc(file=sys.stdout) - if sshp.poll() is None: + if not sshp is None and sshp.poll() is None: if sys.hexversion >= 0x020600F0: sshp.terminate() else: @@ -199,27 +208,36 @@ def trackSensorStatusThread(uwscfg,status_tracker,connection_listener): else: subprocess.call(["kill","-9",str(sshp.pid)]) time.sleep(5) - +door_sockhandle=None +door_socklock=threading.Lock() def trackDoorStatusThread(uwscfg, status_tracker,connection_listener): + global door_sockhandle, door_socklock, threads_running #socket.setdefaulttimeout(10.0) #affects all new Socket Connections (urllib as well) - RE_STATUS = re.compile(r'Status: (\w+), idle') - RE_REQUEST = re.compile(r'Request: (\w+) (?:Card )?(.+)') - RE_ERROR = re.compile(r'Error: (.+)') - while True: + RE_STATUS = re.compile(r'Status: (closed|opened), (opening|waiting|closing|idle), (ajar|shut).*',re.I) + RE_REQUEST = re.compile(r'Request: (\w+) (?:(Card|Phone|SSH|ssh) )?(.+)',re.I) + RE_ERROR = re.compile(r'Error: (.+)',re.I) + while threads_running: uwscfg.checkConfigUpdates() + with door_socklock: + conn=None + door_sockhandle=None try: if not os.path.exists(uwscfg.door_cmd_socket): logging.debug("Socketfile '%s' not found, waiting 5 secs" % uwscfg.door_cmd_socket) time.sleep(5) continue - sockhandle = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) - sockhandle.connect(uwscfg.door_cmd_socket) - conn = os.fdopen(sockhandle.fileno()) - sockhandle.send("listen\n") - sockhandle.send("status\n") - last_who=None - while True: + with door_socklock: + door_sockhandle = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + door_sockhandle.connect(uwscfg.door_cmd_socket) + conn = os.fdopen(door_sockhandle.fileno()) + door_sockhandle.send("listen\n") + door_sockhandle.send("status\n") + + last_who = None + last_how = None + while threads_running: + #no lock here, we're just blocking and reading line = conn.readline() logging.debug("trackDoorStatusThread: Got Line: " + line) @@ -230,28 +248,45 @@ def trackDoorStatusThread(uwscfg, status_tracker,connection_listener): m = RE_STATUS.match(line) if not m is None: - status = m.group(1) - if status == "opened": - status_tracker.doorOpen(last_who) - if status == "closed": - status_tracker.doorClosed(last_who) - last_who = None + (status, current_operation, ajar_status) = m.group(1,2,3) + #REALLY: doorOpen/Closed should be called before doorLocked/Unlocked + if ajar_status == "ajar": + status_tracker.doorOpen() + else: + status_tracker.doorClosed() + if current_operation == "idle": + if status == "opened": + status_tracker.doorUnlocked(last_who, last_how) + if status == "closed": + status_tracker.doorLocked(last_who, last_how) + last_who = None + last_how = None continue m = RE_REQUEST.match(line) if not m is None: - last_who = m.group(2) + last_who = m.group(3) + last_how = m.group(2) continue except Exception, ex: logging.error("main: "+str(ex)) traceback.print_exc(file=sys.stdout) try: - sockhandle.close() + with door_socklock: + if not door_sockhandle is None: + door_sockhandle.close() except: pass - conn=None - sockhandle=None + with door_socklock: + conn=None + door_sockhandle=None time.sleep(5) +def updateDoorStatus(): + global door_sockhandle, door_socklock + with door_socklock: + if not door_sockhandle is None: + door_sockhandle.send("status\n") + ############ Status Tracker Class ############ class StatusTracker: #(threading.Thread): @@ -259,59 +294,101 @@ class StatusTracker: #(threading.Thread): self.uwscfg=uwscfg self.status_change_handler = None #State locked by self.lock - self.door_open=False + self.door_unlocked_previously=None + self.door_unlocked=False + self.door_closed=True self.door_manual_switch_used=False + self.door_physically_present=True + self.door_who=None self.last_door_operation_unixts=0 self.last_movement_unixts=0 self.last_light_value=0 self.last_light_unixts=0 - self.lock=threading.Lock() + self.lock=threading.RLock() #Notify State locked by self.presence_notify_lock self.last_somebody_present_result=False - self.presence_notify_lock=threading.Lock() + self.last_warning=None + self.count_same_warning=0 + self.who_might_be_here=None + self.presence_notify_lock=threading.RLock() #timer self.timer=None - - def doorOpen(self,who): + self.timer_timeout=0 + self.num_movements_during_nonpresences = 0 + + def doorOpen(self): + logging.debug("doorOpen()") + self.door_closed=False + #future other stuff + + def doorClosed(self): + logging.debug("doorClosed()") + self.door_closed=True + #future other stuff + + def doorUnlocked(self,who,how): self.uwscfg.checkConfigUpdates() self.lock.acquire() - self.door_open=True - self.door_manual_switch_used=(who is None or len(who) == 0) - self.last_door_operation_unixts=time.time() + self.door_unlocked=True + self.door_closed=True + if self.door_unlocked != self.door_unlocked_previously: + self.door_who=who + self.lock.release() + self.updateWhoMightBeHere(who) + self.lock.acquire() + self.door_manual_switch_used=(who is None or len(who) == 0) + self.door_physically_present=(self.door_manual_switch_used or (not how is None and how.startswith("Card"))) + if not self.door_unlocked_previously is None: + self.last_door_operation_unixts=time.time() + self.lock.release() + self.checkPresenceStateChangeAndNotify() + self.lock.acquire() + self.door_unlocked_previously = self.door_unlocked self.lock.release() - self.checkPresenceStateChangeAndNotify() - - def doorClosed(self,who): + logging.debug("doorUnlocked: open: %s, who: %s, how: %s, manual_switch: %s; physically_present: %s" % (self.door_unlocked,self.door_who,how,self.door_manual_switch_used,self.door_physically_present)) + + def doorLocked(self,who,how): self.uwscfg.checkConfigUpdates() self.lock.acquire() - self.door_open=False - self.door_manual_switch_used=(who is None or len(who) == 0) - self.last_door_operation_unixts=time.time() + self.door_unlocked=False + if self.door_unlocked != self.door_unlocked_previously: + self.door_who=who + self.lock.release() + self.updateWhoMightBeHere(who) + self.lock.acquire() + self.door_manual_switch_used=(who is None or len(who) == 0) + self.door_physically_present=(self.door_manual_switch_used or (not how is None and how.startswith("Card"))) + if not self.door_unlocked_previously is None: + self.last_door_operation_unixts=time.time() + self.lock.release() + self.checkPresenceStateChangeAndNotify() + self.lock.acquire() + self.door_unlocked_previously = self.door_unlocked self.lock.release() - self.checkPresenceStateChangeAndNotify() + logging.debug("doorLocked: open: %s, who: %s, how:%s, manual_switch: %s; physically_present: %s" % (self.door_unlocked,self.door_who,how,self.door_manual_switch_used,self.door_physically_present)) def movementDetected(self): self.uwscfg.checkConfigUpdates() self.lock.acquire() self.last_movement_unixts=time.time() self.lock.release() + #FIXME: QUICKFIX ignore movement + return self.checkPresenceStateChangeAndNotify() def currentLightLevel(self, value): self.uwscfg.checkConfigUpdates() self.last_light_unixts=time.time() - self.last_light_value=value; + self.last_light_value=value self.checkPresenceStateChangeAndNotify() def checkLight(self, somebody_present=None): if somebody_present is None: somebody_present=self.somebodyPresent() - if self.last_light_value > self.uwscfg.tracker_photo_flashlight: + if self.last_light_value > int(self.uwscfg.tracker_photo_flashlight): return "Light: flashlight" - elif self.last_light_value > self.uwscfg.tracker_photo_daylight: - return "Light: daylight" - elif self.last_light_value > self.uwscfg.tracker_photo_artif_light: + elif self.last_light_value > int(self.uwscfg.tracker_photo_artif_light): if not somebody_present and self.last_light_unixts > self.last_door_operation_unixts: return "Light: forgotten" else: @@ -319,32 +396,106 @@ class StatusTracker: #(threading.Thread): else: return "Light: off" + def checkAgainIn(self, sec): + if sec <= 0.0: + return + if self.timer_timeout < time.time(): + logging.debug("checkAgainIn: starting Timer with timeout %fs" % sec) + self.timer=threading.Timer(sec, self.checkPresenceStateChangeAndNotify) + self.timer.start() + self.timer_timeout = time.time() + sec + else: + logging.debug("checkAgainIn: not starting timer, already one scheduled in %fs" % (time.time() - self.timer_timeout)) - #TODO: check brightness level from cam or an arduino sensor def somebodyPresent(self): - global uwscfg with self.lock: - if (self.door_open): - return True - elif (time.time() - self.last_door_operation_unixts <= self.uwscfg.tracker_sec_wait_movement): - #start timer, checkPresenceStateChangeAndNotify after tracker_sec_wait_movement - if not self.timer is None: - self.timer.cancel() - self.timer=threading.Timer(self.uwscfg.tracker_sec_wait_movement, self.checkPresenceStateChangeAndNotify) - self.timer.start() + #door unlocked: + if self.door_unlocked: + self.num_movements_during_nonpresences = 0 + if self.door_physically_present: + return True + #door is ajar and unlocked then we are here for sure: + elif self.door_closed == False: + return True + elif self.last_movement_unixts > self.last_door_operation_unixts: + return True + else: + return False + # door locked but still ajar: + elif self.door_closed == False: #and elf.door_unlocked == False return True - elif (self.last_movement_unixts > self.last_door_operation_unixts and (self.door_manual_switch_used or ( time.time() - self.last_movement_unixts < self.uwscfg.tracker_sec_general_movement_timeout))): + # door not locked from inside, but with card/phone .. check again in ... + elif not self.door_manual_switch_used and time.time() - self.last_door_operation_unixts <= float(self.uwscfg.tracker_sec_wait_after_close_using_cardphone): + self.num_movements_during_nonpresences = 0 + self.checkAgainIn(float(self.uwscfg.tracker_sec_wait_after_close_using_cardphone)) + return self.last_somebody_present_result + # door locked from inside, and door not ajar + elif self.door_manual_switch_used and self.door_closed: return True +# # door locked from inside, stay on last status .... +# elif self.door_manual_switch_used and time.time() - self.last_door_operation_unixts <= float(self.uwscfg.tracker_sec_wait_after_close_using_manualswitch): +# self.num_movements_during_nonpresences = 0 +# self.checkAgainIn(float(self.uwscfg.tracker_sec_wait_after_close_using_manualswitch)) +# return self.last_somebody_present_result +# # door locked from inside and movement detected around that time +# elif self.door_manual_switch_used and self.last_movement_unixts > self.last_door_operation_unixts - float(self.uwscfg.tracker_sec_movement_before_manual_switch): +# self.num_movements_during_nonpresences = 0 +# return True + ##door was closed and nobody here But movement is dedected: + #elif self.last_movement_unixts > self.last_door_operation_unixts and time.time() - self.last_movement_unixts < float(self.uwscfg.tracker_sec_general_movement_timeout): + # self.num_movements_during_nonpresences += 1 + # if self.num_movements_during_nonpresences >= int(self.uwscfg.tracker_num_movements_req_on_nonpresence_until_present): + # return True + # else: + # return False else: + self.num_movements_during_nonpresences = 0 return False + def getPossibleWarning(self): + with self.lock: + somebody_present=self.last_somebody_present_result + if not somebody_present and not self.door_closed: + return "Nobody here but door ajar !" + elif self.door_unlocked and not somebody_present and time.time() - self.last_door_operation_unixts >= float(self.uwscfg.tracker_sec_wait_for_movement_before_warning): + return "Door unlocked recently but nobody present" + elif self.door_unlocked and not somebody_present: + self.checkAgainIn(float(self.uwscfg.tracker_sec_wait_for_movement_before_warning)) + return None +# elif not somebody_present and self.last_light_unixts > self.last_door_operation_unixts and self.last_light_value > int(self.uwscfg.tracker_photo_artif_light): +#return "Nobody here but light is still on" + else: + return None + + def updateWhoMightBeHere(self, who): + with self.presence_notify_lock: + self.who_might_be_here = who + + def forgetWhoMightBeHere(self, somebody_present): + with self.presence_notify_lock: + if not somebody_present: + self.who_might_be_here = None + def checkPresenceStateChangeAndNotify(self): + #no acquiring of self.lock, "just" reading. chance wrong reads in favour of avoiding race conditions (is python var _read_ threadsafe ?) with self.presence_notify_lock: somebody_present = self.somebodyPresent() + logging.debug("checkPresenceStateChangeAndNotify: somebody_present=%s, door_locked=%s, door_ajar=%s, door_who=%s, who=%s, light=%s" % (somebody_present,not self.door_unlocked, not self.door_closed, self.door_who,self.who_might_be_here, str(self.last_light_value))) if somebody_present != self.last_somebody_present_result: self.last_somebody_present_result = somebody_present if not self.status_change_handler is None: - self.status_change_handler(somebody_present) + self.status_change_handler(somebody_present, door_open=self.door_unlocked, who=self.who_might_be_here) + self.forgetWhoMightBeHere(somebody_present) + warning = self.getPossibleWarning() + if warning == self.last_warning: + self.count_same_warning+=1 + else: + self.last_warning=warning + self.count_same_warning=0 + if not warning is None and self.count_same_warning < 3: + logging.debug("checkPresenceStateChangeAndNotify: warning: " + str(warning)) + if not self.status_change_handler is None: + self.status_change_handler(somebody_present=None, door_open=self.door_unlocked, who=self.who_might_be_here, warning=warning) ############ Connection Listener ############ class ConnectionListener: @@ -359,14 +510,37 @@ class ConnectionListener: self.client_sockets=[] self.lock=threading.Lock() - def statusString(self,somebody_present): + def shutdown(self): + self.running=False + try: + self.server_socket.close() + except: + pass + with self.lock: + for sock_to_close in self.client_sockets: + try: + sock_to_close.close() + except: + pass + + def statusString(self,somebody_present, door_open=None, who=None): + details="" + if not who is None: + if door_open: + details=", opened, " + else: + details=", closed, " + details += who if somebody_present: - return "Presence: yes" + "\n" + return "Presence: yes" + details + "\n" else: - return "Presence: no" + "\n" + return "Presence: no" + details + "\n" - def updateStatus(self,somebody_present): - self.distributeData(self.statusString(somebody_present)) + def updateStatus(self,somebody_present=None,door_open=None,who=None,warning=None): + if not somebody_present is None: + self.distributeData(self.statusString(somebody_present, door_open, who)) + if not warning is None: + self.distributeData("Warning: " + warning + "\n") def distributeData(self,data): with self.lock: @@ -389,6 +563,7 @@ class ConnectionListener: newsocketconn.send(self.statusString(self.status_tracker.somebodyPresent())) with self.lock: self.client_sockets.append(newsocketconn) + updateDoorStatus() else: #drop all recieved data and watch for closed sockets if not socket_to_read.recv(256): @@ -403,7 +578,22 @@ class ConnectionListener: ############ Main Routine ############ def exitHandler(signum, frame): + global threads_running, connection_listener, sshp, door_sockhandle logging.info("Track Presence stopping") + threads_running=False + connection_listener.shutdown() + try: + if sys.hexversion >= 0x020600F0: + sshp.terminate() + else: + subprocess.call(["kill",str(sshp.pid)]) + except: + pass + try: + door_sockhandle.close() + except: + pass + time.sleep(0.1) sys.exit(0) #signals proapbly don't work because of readline