update the SpaceAPI at least once every 10 minutes (so the server could check for...

diff --git a/spaceapi.py b/spaceapi.py
index dd722b972ffb52bc8ee9af0d1184f87fc387b54c..eea73f6a2a708fb3061617527e60fb10a76207f7 100644 (file)
--- a/spaceapi.py
+++ b/spaceapi.py
@@ -1,17 +1,20 @@
 from threading import Lock
 from libtuer import ThreadFunction, logger
 from threading import Lock
 from libtuer import ThreadFunction, logger

-import urllib.request
+import urllib.request, time

 
 from config import spaceApiKey
 
 
 from config import spaceApiKey
 

+RETRY_TIME = 30
+HEARTBEAT_TIME = 10*60
+

 class SpaceApi:
        def __init__ (self, waker):
 class SpaceApi:
        def __init__ (self, waker):

-               self._state_to_set = None
-               self._state_last_set = None
+               self._local_state = None
+               self._remote_state = None
+               self._last_set_at = 0

                self._running = True
                self.set_state = ThreadFunction(self._set_state, "Space API")
                self._running = True
                self.set_state = ThreadFunction(self._set_state, "Space API")

-               self._set_state_lock = Lock()
-               waker.register(self.set_state, 10.0) # re-try setting the state every 10 seconds
+               waker.register(self.set_state, RETRY_TIME)

        
        def stop (self):
                self.set_state.stop()
        
        def stop (self):
                self.set_state.stop()


@@ -34,24 +37,14 @@ class SpaceApi:
        def _set_state (self, state = None):
                '''Sets the state, if None: leave state unchanged and re-try if previous attempts failed'''
                if state is not None:
        def _set_state (self, state = None):
                '''Sets the state, if None: leave state unchanged and re-try if previous attempts failed'''
                if state is not None:

-                       self._state_to_set = state
-               else:
-                       # always have a local variable because of parallelism
-                       state = self._state_to_set
-               
-               if not self._set_state_lock.acquire(False):
-                       # we don't want many threads to wait here
-                       # the next status update will fix everything anyways
-                       pass
-               else:
-                       # got the lock
-                       try:
-                               # check if there's something we need to do
-                               if self._state_last_set == state: return
-                               # take action!
-                               success = self._do_request(state)
-                               # TODO error too often -> log critical to send mails
-                               if success:
-                                       self._state_last_set = state
-                       finally:
-                               self._set_state_lock.release()
+                       self._local_state = state
+               # check if there's something we need to do: There's a valid state, and either the state has changed or
+               # we need to refresh our heartbeta)
+               now = time.time()
+               if self._local_state is not None and (self._local_state != self._remote_state or now > self._last_set_at+HEARTBEAT_TIME):
+                       # take action!
+                       success = self._do_request(self._local_state)
+                       # TODO error too often -> log critical to send mails
+                       if success:
+                               self._remote_state = self._local_state
+                               self._last_set_at = now