More changes for python3 and improved logging/debugging. This ~works.

diff --git a/chooser.py b/chooser.py
index f6a9a497d3cd6c1205e6e31e81cee340c7056247..df662da35a930a83d5d41860b24f44145f023d66 100644 (file)
--- a/chooser.py
+++ b/chooser.py
@@ -25,7 +25,7 @@ class chooser(object):
                         os.path.join(constants.pages_dir, page)))
                     age = (now - last_modified)
                     if (age > freshness_requirement):
-                        print(('"%s" is too old.' % page))
+                        print(('chooser: "%s" is too old.' % page))
                         continue
                 filenames.append(page)
         return filenames

diff --git a/health_renderer.py b/health_renderer.py
index 55e4cf937d25aca755fa6264cc561bd06fc7baf2..4eeba985163d8d512ef8f60ce3151e09ddc6262c 100644 (file)
--- a/health_renderer.py
+++ b/health_renderer.py
@@ -134,4 +134,5 @@ class periodic_health_renderer(renderer.debuggable_abstaining_renderer):
 </BODY>
 </HTML>""")
 
-#test = periodic_health_renderer({"Test", 123})
+test = periodic_health_renderer({"Test", 123})
+test.periodic_render("Test")

diff --git a/kiosk.py b/kiosk.py
index b7fb9d96cc728625cfe635bf242d075979397be0..f25a659c17bb153a08281b0c5c5743ad59fde0d4 100755 (executable)
--- a/kiosk.py
+++ b/kiosk.py
@@ -25,43 +25,51 @@ def thread_change_current():
         (page, triggered) = page_chooser.choose_next_page()
 
         if triggered:
-            print(('chooser[%s] - WE ARE TRIGGERED.' % utils.timestamp()))
+            print('chooser[%s] - WE ARE TRIGGERED.' % utils.timestamp())
             if page != last_page:
-                print(('chooser[%s] - EMERGENCY PAGE %s LOAD NEEDED' % (
-                    utils.timestamp(), page)))
-                f = open(os.path.join(constants.pages_dir,
-                                      "current.shtml"), "w")
-                emit_wrapped(f, page)
-                f.close()
+                print('chooser[%s] - EMERGENCY PAGE %s LOAD NEEDED' % (
+                    utils.timestamp(), page))
+                try:
+                    f = open(os.path.join(constants.pages_dir,
+                                          'current.shtml'), 'w')
+                    emit_wrapped(f, page)
+                    f.close()
+                except:
+                    print('chooser[%s] - page does not exist?!' % (
+                        utils.timestamp()))
+                    continue
+                last_page = page
+                swap_page_target = now + constants.refresh_period_sec
 
-                # Notify XMLHTTP clients that they need to refresh now.
+                # Also notify XMLHTTP clients that they need to refresh now.
                 path = os.path.join(constants.pages_dir,
-                                    "reload_immediately.html")
+                                    'reload_immediately.html')
                 f = open(path, 'w')
-                f.write("Reload, suckers!")
+                f.write('Reload, suckers!')
                 f.close()
+
+                # Fix this hack... maybe read the webserver logs and see if it
+                # actually was picked up?
                 time.sleep(0.750)
                 os.remove(path)
-                last_page = page
-                swap_page_target = now + constants.refresh_period_sec
 
         elif now >= swap_page_target:
             if (page == last_page):
                 print(('chooser[%s] - nominal choice got the same page...' % (
                     utils.timestamp())))
                 continue
-            print(('chooser[%s] - nominal choice of %s' % (utils.timestamp(), page)))
+            print('chooser[%s] - nominal choice of %s' % (utils.timestamp(), page))
             try:
                 f = open(os.path.join(constants.pages_dir,
-                                      "current.shtml"), "w")
+                                      'current.shtml'), 'w')
                 emit_wrapped(f, page)
                 f.close()
-                last_page = page
-                swap_page_target = now + constants.refresh_period_sec
             except:
-                print(('chooser[%s] - page does not exist?!' % (utils.timestamp())))
+                print('chooser[%s] - page does not exist?!' % (utils.timestamp()))
                 continue
-        time.sleep(1.0)
+            last_page = page
+            swap_page_target = now + constants.refresh_period_sec
+        time.sleep(1)
 
 def pick_background_color():
     now = datetime.now()
@@ -242,19 +250,26 @@ def emit_wrapped(f, filename):
 
 def thread_invoke_renderers():
     while True:
-        print("Renderer thread[%s]: invoking all renderers in catalog..." % (
+        print("renderer[%s]: invoking all renderers in catalog..." % (
             utils.timestamp()))
         for r in renderer_catalog.get_renderers():
+            now = time.time()
+            print("renderer[%s]: Rendering %s" % (utils.timestamp(), r.get_name()))
             try:
                 r.render()
             except Exception as e:
                 traceback.print_exc()
-                print(("renderer[%s] unknown exception, swallowing it." % (
-                    utils.timestamp())))
+                print("renderer[%s] unknown exception in %s, swallowing it." % (
+                    utils.timestamp(), r.get_name()))
             except Error as e:
                 traceback.print_exc()
-                print(("renderer[%s] unknown error, swallowing it." % (
-                    utils.timestamp())))
+                print("renderer[%s] unknown error in %s, swallowing it." % (
+                    utils.timestamp(), r.get_name()))
+            delta = time.time() - now
+            print("renderer[%s]: Back from %s, that took %5.2fs." % (
+                utils.timestamp(), r.get_name(), delta))
+        print("renderer[%s]: thread having a little break for %ds..." % (
+            utils.timestamp(), constants.render_period_sec))
         time.sleep(constants.render_period_sec)
 
 if __name__ == "__main__":
@@ -264,13 +279,15 @@ if __name__ == "__main__":
     while True:
         if (changer_thread == None or
             not changer_thread.is_alive()):
-            print(("chooser[%s] - (Re?)initializing chooser thread..." % utils.timestamp()))
+            print("MAIN[%s] - (Re?)initializing chooser thread..." % (
+                utils.timestamp()))
             changer_thread = Thread(target = thread_change_current, args=())
             changer_thread.start()
         if (renderer_thread == None or
             not renderer_thread.is_alive()):
-            print(("renderer[%s] - (Re?)initializing render thread..." % utils.timestamp()))
+            print("MAIN[%s] - (Re?)initializing render thread..." % (
+                utils.timestamp()))
             renderer_thread = Thread(target = thread_invoke_renderers, args=())
             renderer_thread.start()
-        time.sleep(10000)
+        time.sleep(60)
     print("Should never get here.")

diff --git a/reddit_renderer.py b/reddit_renderer.py
index 89ccfb4d885a2b3cf0a40bccc3e9cc52311ceb41..c0b31aef26aec1c376b303bab8d0fd4492aa0b58 100644 (file)
--- a/reddit_renderer.py
+++ b/reddit_renderer.py
@@ -64,12 +64,12 @@ class reddit_renderer(renderer.debuggable_abstaining_renderer):
     </TD>
   </TR>
 </TABLE>""" % (self.font_size, content, msg.title, msg.author)
-                    self.messages.add(x.encode('utf8'))
+                    self.messages.add(x)
                 except:
                     self.debug_print('Unexpected exception, skipping message.')
             else:
                 self.debug_print('skipped message "%s" for profanity or low score' % (
-                    msg.title.encode('utf8')))
+                    msg.title))
 
     def scrape_reddit(self):
         self.deduper.clear()

diff --git a/renderer.py b/renderer.py
index 34e4459d429abda03a28da88048690cbc0834f0c..491d34d52f9b32a9090294b40c21358e42f892fd 100644 (file)
--- a/renderer.py
+++ b/renderer.py
@@ -6,6 +6,9 @@ class renderer(object):
     def render(self):
         pass
 
+    def get_name(self):
+        return self.__class__.__name__
+
 class abstaining_renderer(renderer):
     """A renderer that doesn't do it all the time."""
     def __init__(self, name_to_timeout_dict):
@@ -17,33 +20,32 @@ class abstaining_renderer(renderer):
     def should_render(self, keys_to_skip):
         now = time.time()
         for key in self.name_to_timeout_dict:
-            if key in keys_to_skip:
-                continue
-            if (now - self.last_runs[key]) > self.name_to_timeout_dict[key]:
+            if (((now - self.last_runs[key]) > self.name_to_timeout_dict[key]) and
+                key not in keys_to_skip):
                 return key
         return None
 
     def render(self):
-        tries = {}
+        tries_per_key = {}
         keys_to_skip = set()
         while True:
             key = self.should_render(keys_to_skip)
             if key == None:
                 break
-            if key in tries:
-                tries[key] += 1
+
+            if key in tries_per_key:
+                tries_per_key[key] += 1
             else:
-                tries[key] = 0
+                tries_per_key[key] = 0
 
-            if tries[key] > 5:
-                print(('Too many retries for "%s.%s", giving up for now' % (
-                    key, self.__class__)))
+            if tries_per_key[key] >= 3:
+                print('renderer: Too many failures/retries for "%s.%s", ' +
+                      ', giving up for now' % (self.get_name(), key))
                 keys_to_skip.add(key)
             else:
-                msg = 'renderer: periodic render event for "%s.%s"' % (
-                    key, self.__class__)
-                if (tries[key] > 1):
-                    msg = msg + " (try %d)" % tries[key]
+                msg = 'renderer: executing "%s.%s"' % (self.get_name(), key)
+                if (tries_per_key[key] > 1):
+                    msg = msg + " (retry %d)" % tries_per_key[key]
                 print(msg)
                 if (self.periodic_render(key)):
                     self.last_runs[key] = time.time()
@@ -57,7 +59,7 @@ class debuggable_abstaining_renderer(abstaining_renderer):
         self.debug = debug
 
     def debug_prefix(self):
-        return "none"
+        return self.get_name()
 
     def being_debugged(self):
         return self.debug

diff --git a/renderer_catalog.py b/renderer_catalog.py
index 3cd8406b4d2b8e02770dc54682162d3874df829f..b3b3e112fd7cb2fab1f028a93ada9ae87aab823f 100644 (file)
--- a/renderer_catalog.py
+++ b/renderer_catalog.py
@@ -43,9 +43,9 @@ __registry = [
                       "Shuffle Events" : (always)}),
 #                 pollen_renderer.pollen_count_renderer(
 #                     {"Poll" : (hours * 1)}),
-                 myq_renderer.garage_door_renderer(
-                     {"Poll MyQ" : (minutes * 5),
-                      "Update Page" : (minutes * 5)}),
+#                 myq_renderer.garage_door_renderer(
+#                     {"Poll MyQ" : (minutes * 5),
+#                      "Update Page" : (minutes * 5)}),
                  bellevue_reporter_rss_renderer.bellevue_reporter_rss_renderer(
                      {"Fetch News" : (hours * 1),
                       "Shuffle News" : (always)},